create-principles-disciple 1.145.8 → 1.145.10

package/host-runtime/dist/governance-signal-admission.js

@@ -34,7 +34,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
-import { collectSync, CORRECTION_SEED_KEYWORDS, buildToolFailureObservation, evaluateTriage, evaluateTriggerController, resolveSourceKind, PainToPrincipleService, PrincipleTreeLedgerAdapter, RuntimeStateManager, createDiagnosticianTaskId, disposePainSignalBridgesForWorkspace, sanitizeString, boundCorrectionEvidenceText, MAX_EVIDENCE_VALUE_CHARS, } from '@principles/core/runtime-v2';
+import { collectSync, computeFeatureFlagsFromConfig, CORRECTION_SEED_KEYWORDS, buildToolFailureObservation, evaluateTriage, evaluateTriggerController, resolveSourceKind, PainToPrincipleService, PrincipleTreeLedgerAdapter, RuntimeStateManager, createDiagnosticianTaskId, disposePainSignalBridgesForWorkspace, sanitizeString, boundCorrectionEvidenceText, MAX_EVIDENCE_VALUE_CHARS, } from '@principles/core/runtime-v2';
 import { deriveProductionCorrectionPainIdentity, deriveProductionToolPainIdentity, hasProductionPainSchema, PRODUCTION_WRITE_TOOLS, } from './production-pain-evidence.js';
 import { promoteGovernanceEvidence, ensureGovernanceSchema } from './governance-observation-store.js';
 import { loadPdConfigForPlugin } from './pd-config.js';
@@ -303,13 +303,23 @@ function ensureGovernanceAdmissionSchema(db) {
         if (hasToolCalls) {
             try {
                 db.exec('ALTER TABLE tool_calls ADD COLUMN tool_use_id TEXT');
-                db.exec('CREATE INDEX IF NOT EXISTS idx_tool_calls_session_tool_use_id ON tool_calls(session_id, tool_use_id)');
             }
             catch (err) {
                 const message = err instanceof Error ? err.message : String(err);
                 if (!message.includes('duplicate column name'))
                     throw err;
             }
+            try {
+                // Additive project scope for live Codex admission rows. Existing rows
+                // deliberately remain NULL because their originating cwd is unknown.
+                db.exec('ALTER TABLE tool_calls ADD COLUMN project_dir TEXT');
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                if (!message.includes('duplicate column name'))
+                    throw err;
+            }
+            db.exec('CREATE INDEX IF NOT EXISTS idx_tool_calls_session_tool_use_id ON tool_calls(session_id, tool_use_id)');
         }
     })();
 }
@@ -422,7 +432,8 @@ function toolFailureTaskPayload(fields) {
     };
     return JSON.stringify(payload);
 }
-function taskSubmissionPayload(candidate, workspaceDir, reason) {
+function taskSubmissionPayload(candidate, workspaceDir, details) {
+    const { reason, canonicalPainId } = details;
     if (candidate.kind === 'user_correction') {
         // P1-1 privacy (review round 2): sanitize the FULL text before any
         // truncation — a token crossing the 200-char boundary must be redacted, not
@@ -436,9 +447,14 @@ function taskSubmissionPayload(candidate, workspaceDir, reason) {
             hostKind: candidate.hostKind,
             // WorkBuddy explicit intake has no transcript observation to promote.
             // The classified Owner statement is its input basis, not a pseudo-trace.
-            evidence: candidate.hostKind === 'workbuddy' && candidate.explicitOwnerStatement === true
-                ? []
-                : [{ sourceRef: `governance_observation:${candidate.logicalObservationKey}`, note: sanitizeString(candidate.text, workspaceDir) }],
+            evidence: candidate.hostKind === 'workbuddy'
+                ? candidate.explicitOwnerStatement === true ? [] : [{
+                        // WorkBuddy has no governance_observation, anchor to the canonical
+                        // Pain persisted in this same trajectory.db transaction.
+                        sourceRef: 'pain_event:' + (canonicalPainId ?? ''),
+                        note: sanitizeString(candidate.text, workspaceDir),
+                    }]
+                : [{ sourceRef: 'governance_observation:' + candidate.logicalObservationKey, note: sanitizeString(candidate.text, workspaceDir) }],
             // SPEC-CODEX-PAIN-CLOSURE-001 CR-02 (merged from main): an explicit
             // Owner statement rides as classified correction evidence — never
             // summarized by an AI, never inside evidence[] pseudo-trace entries.
@@ -534,7 +550,7 @@ function admitCorrection({ db, candidate, workspaceDir, now, nowIso, keywordStor
                 // detection, so `detection` is optional — no ruleVersion exists for them.
                 ruleVersion: detection?.ruleVersion ?? null,
                 reason,
-                payloadJson: taskSubmissionPayload(candidate, workspaceDir, reason),
+                payloadJson: taskSubmissionPayload(candidate, workspaceDir, { reason, canonicalPainId: painId }),
                 nowIso,
             });
         })();
@@ -608,8 +624,11 @@ function admitToolFailure({ db, candidate, workspaceDir, nowIso }) {
         else {
             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(candidate.rootSessionId, nowIso, nowIso);
-            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) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                .run(candidate.rootSessionId, candidate.toolName, outcome.outcome, outcome.durationMs ?? null, outcome.exitCode, outcome.error ? outcome.error.split(/[\s:]/, 1)[0] : null, outcome.error ?? null, null, null, paramsJson, resultPreview, nowIso, candidate.toolUseId ?? null);
+            const projectDir = typeof candidate.projectDir === 'string' && path.isAbsolute(candidate.projectDir)
+                ? path.resolve(candidate.projectDir)
+                : null;
+            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) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+                .run(candidate.rootSessionId, candidate.toolName, outcome.outcome, outcome.durationMs ?? null, outcome.exitCode, outcome.error ? outcome.error.split(/[\s:]/, 1)[0] : null, outcome.error ?? null, null, null, paramsJson, resultPreview, nowIso, candidate.toolUseId ?? null, projectDir);
             reason = `tool=${candidate.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(candidate.rootSessionId, sourceObservation.failureSource ?? 'tool_failure', painScore, reason, painScore >= 70 ? 'severe' : painScore >= 40 ? 'moderate' : 'mild', 'system_infer', null, null, painId, null, candidate.hostKind, nowIso);
@@ -624,7 +643,7 @@ function admitToolFailure({ db, candidate, workspaceDir, nowIso }) {
                 canonicalPainId: painId,
                 ruleVersion: null,
                 reason: sanitizeString(reason, workspaceDir),
-                payloadJson: taskSubmissionPayload(candidate, workspaceDir, reason),
+                payloadJson: taskSubmissionPayload(candidate, workspaceDir, { reason }),
                 nowIso,
             });
         }
@@ -637,8 +656,8 @@ function admitToolFailure({ db, candidate, workspaceDir, nowIso }) {
     }
     return { disposition: 'admitted', kind: 'tool_failure', logicalObservationKey: candidate.logicalObservationKey, canonicalPainId: painId, duplicate, ruleVersion: null };
 }
-function admitOne({ db, candidate, workspaceDir, now, nowIso, keywordStore, onDegradation }) {
-    if (candidate.hostKind !== 'codex' && !(candidate.hostKind === 'workbuddy' && candidate.kind === 'user_correction' && candidate.explicitOwnerStatement === true)) {
+function admitOne({ db, candidate, workspaceDir, now, nowIso, keywordStore, onDegradation, trustedWorkbuddyLive }) {
+    if (candidate.hostKind !== 'codex' && !(candidate.hostKind === 'workbuddy' && candidate.kind === 'user_correction' && (candidate.explicitOwnerStatement === true || trustedWorkbuddyLive === true))) {
         return { ok: false, reason: 'unsupported_host_kind', nextAction: 'governance signal admission accepts Codex observations or explicit WorkBuddy Owner statements' };
     }
     const marker = db.prepare('SELECT * FROM governance_signal_admissions WHERE logical_observation_key = ?').get(candidate.logicalObservationKey);
@@ -663,7 +682,7 @@ function admitOne({ db, candidate, workspaceDir, now, nowIso, keywordStore, onDe
  * trajectory.db transaction (marker + pain row + quota together), so one
  * failing candidate never rolls back another's admission.
  */
-export function admitGovernanceSignals(input) {
+function admitGovernanceSignalsInternal(input, trustedWorkbuddyLive = false) {
     const opened = openAdmissionStore(input.workspaceDir, input.databaseFactory);
     if (!('db' in opened))
         return opened;
@@ -678,7 +697,7 @@ export function admitGovernanceSignals(input) {
     const outcomes = [];
     try {
         for (const candidate of input.candidates) {
-            outcomes.push(admitOne({ db, candidate, workspaceDir, now, nowIso, ...(input.keywordStore ? { keywordStore: input.keywordStore } : {}), ...(input.onDegradation ? { onDegradation: input.onDegradation } : {}) }));
+            outcomes.push(admitOne({ db, candidate, workspaceDir, now, nowIso, ...(input.keywordStore ? { keywordStore: input.keywordStore } : {}), ...(input.onDegradation ? { onDegradation: input.onDegradation } : {}), trustedWorkbuddyLive }));
         }
         return { ok: true, outcomes };
     }
@@ -690,6 +709,87 @@ export function admitGovernanceSignals(input) {
         close();
     }
 }
+/** Public generic intake stays Codex + explicit WorkBuddy only. */
+export function admitGovernanceSignals(input) {
+    return admitGovernanceSignalsInternal(input);
+}
+/** P0: a four-term projection of existing canonical high-precision seeds. */
+const WORKBUDDY_AUTO_TERMS = new Set(['这是错的', '不要自作主张', '不应该这么做', '又搞错']);
+const WORKBUDDY_MAX_PROMPT_BYTES = 16 * 1024;
+function workbuddyP0KeywordStore() {
+    const seed = buildSharedSeedKeywordStore();
+    const terms = {};
+    for (const [term, def] of Object.entries(seed.terms)) {
+        if (WORKBUDDY_AUTO_TERMS.has(term) && def.category === 'correction' && def.precision === 'high') {
+            terms[term] = def;
+        }
+    }
+    return { version: seed.version, terms };
+}
+/** Pure check: no DB, no filesystem, no classifier, no historical transcript. */
+export function assessWorkbuddyLiveKeyword(text, sessionId) {
+    if (Buffer.byteLength(text, 'utf8') > WORKBUDDY_MAX_PROMPT_BYTES) {
+        return { matched: false, reason: 'prompt_too_large' };
+    }
+    const store = workbuddyP0KeywordStore();
+    // Prefer precision to recall: reject quoted/embedded/reported phrases.
+    if (!Object.keys(store.terms).some(term => text.trimStart().toLowerCase().startsWith(term.toLowerCase()))) {
+        return { matched: false, reason: 'not_a_signal' };
+    }
+    const out = collectSync(text, sessionId, store, SYNC_DETECTION_CONFIG, new Date().toISOString());
+    const matched = out.isSignal && out.strength === 'STRONG' &&
+        out.type === 'correction' && out.matchedPrecision === 'high';
+    return { matched, reason: matched ? 'matched' : 'not_a_signal' };
+}
+/**
+ * Narrow native event gateway: validate true current user origin and flags.
+ * The ordinary generic admission API cannot bypass this WorkBuddy gate.
+ */
+export function admitTrustedWorkbuddyLiveCorrection(input) {
+    const raw = input.rawEvent;
+    if (!isRecord(raw) || own(raw, 'hook_event_name') !== 'UserPromptSubmit' ||
+        own(raw, 'is_internal_continuation') !== false) {
+        return { ok: false, reason: 'native_current_user_unverified', nextAction: 'Require a real current WorkBuddy UserPromptSubmit event.' };
+    }
+    const sessionId = own(raw, 'session_id');
+    const generationId = own(raw, 'generation_id');
+    const prompt = own(raw, 'prompt');
+    if (typeof sessionId !== 'string' || !sessionId.trim() ||
+        typeof generationId !== 'string' || !generationId.trim() ||
+        typeof prompt !== 'string') {
+        return { ok: false, reason: 'native_identity_invalid', nextAction: 'Require nonblank native session_id/generation_id and prompt.' };
+    }
+    const config = loadPdConfigForPlugin(input.workspaceDir);
+    if (!config.ok)
+        return { ok: false, reason: 'workbuddy_config_invalid', nextAction: 'Repair WorkBuddy governance workspace config.' };
+    const { flags } = computeFeatureFlagsFromConfig(config.effective);
+    if (flags['host.workbuddy']?.enabled !== true || flags.workbuddy_live_keyword_pain?.enabled !== true) {
+        return { ok: false, reason: 'workbuddy_auto_disabled', nextAction: 'Explicitly enable both WorkBuddy host and live keyword Pain.' };
+    }
+    if (prompt.trimStart().startsWith('PD记录痛苦')) {
+        return { ok: false, reason: 'explicit_owner_statement_reserved', nextAction: 'Use original Owner intake; no keyword fallback.' };
+    }
+    if (!assessWorkbuddyLiveKeyword(prompt, sessionId).matched) {
+        return { ok: true, outcomes: [] };
+    }
+    const nativeIdentity = JSON.stringify(['workbuddy', sessionId, generationId]);
+    return admitGovernanceSignalsInternal({
+        workspaceDir: input.workspaceDir,
+        candidates: [{
+                kind: 'user_correction',
+                hostKind: 'workbuddy',
+                logicalObservationKey: nativeIdentity + '|user',
+                rolloutIdentity: JSON.stringify(['workbuddy', sessionId]),
+                rootSessionId: sessionId,
+                hostTurnId: nativeIdentity,
+                text: prompt,
+                observedAt: (input.now ?? new Date()).toISOString(),
+            }],
+        keywordStore: workbuddyP0KeywordStore(),
+        ...(input.now ? { now: input.now } : {}),
+        ...(input.databaseFactory ? { databaseFactory: input.databaseFactory } : {}),
+    }, true);
+}
 // ─── Diagnostician continuation (one pain → exactly one pending task) ───────
 function isGovernanceTaskPayload(value) {
     if (!isRecord(value))

package/host-runtime/dist/index.d.ts

@@ -87,5 +87,6 @@ export declare function createProductionHostRuntime(options?: Partial<Pick<HostR
 }): HostRuntime;
 export * from './behavior-example-pack-assembler.js';
 export * from './behavior-history.js';
-export * from './workspace-behavior-evidence.js';
+export * from './codex-rule-context-provider.js';
+export { createWorkspaceBehaviorEvidencePort } from './workspace-behavior-evidence.js';
 export * from './explicit-owner-statement-prefix.js';

package/host-runtime/dist/index.js

@@ -181,6 +181,7 @@ export function createHostRuntime(options) {
 }
 export function createProductionHostRuntime(options = {}) {
     const productionGate = createProductionRuleHostGate({
+        ...(options.hostKind ? { hostKind: options.hostKind } : {}),
         ...(options.projectDir ? { projectDir: options.projectDir } : {}),
         ...(options.ruleContextProvider ? { ruleContextProvider: options.ruleContextProvider } : {}),
         ...(options.ruleInputEnrichmentProvider ? { ruleInputEnrichmentProvider: options.ruleInputEnrichmentProvider } : {}),
@@ -192,6 +193,7 @@ export function createProductionHostRuntime(options = {}) {
             ...(options.painEnrichmentProvider ? { painEnrichmentProvider: options.painEnrichmentProvider } : {}),
             ...(options.painDatabaseFactory ? { painDatabaseFactory: options.painDatabaseFactory } : {}),
             ...(options.hostKind ? { hostKind: options.hostKind } : {}),
+            ...(options.projectDir ? { projectDir: options.projectDir } : {}),
             ...(options.events ? { events: options.events } : {}),
         }),
         beforeToolCall: options.beforeToolCall ?? productionGate,
@@ -267,5 +269,6 @@ export function createProductionHostRuntime(options = {}) {
 }
 export * from './behavior-example-pack-assembler.js';
 export * from './behavior-history.js';
-export * from './workspace-behavior-evidence.js';
+export * from './codex-rule-context-provider.js';
+export { createWorkspaceBehaviorEvidencePort } from './workspace-behavior-evidence.js';
 export * from './explicit-owner-statement-prefix.js';

package/host-runtime/dist/internalization-consumer-cycle.js

@@ -693,7 +693,7 @@ export async function runInternalizationConsumerCycle(workspaceDir, ports) {
                 break;
             case 'scribe':
                 runner = new ScribeRunner({
-                    stateManager, runtimeAdapter: adapter, eventEmitter: storeEmitter, artifactStore: stateManager.piArtifactStore, validator: new DefaultScribeValidator(),
+                    stateManager, runtimeAdapter: adapter, eventEmitter: storeEmitter, artifactStore: stateManager.piArtifactStore, validator: new DefaultScribeValidator({ requireRuleCodeContracts: true }),
                     // I2 — CHAIN STAMPING (Owner review of PR #1856, P1): the scribe
                     // stamps the ledger principle UUID (minted at intake, keyed by the
                     // dreamer task seed's candidateId) onto the artifact it writes, so

package/host-runtime/dist/internalization-consumer-governance.js

@@ -170,6 +170,9 @@ export function createEvaluatorRepairDeps(workspaceDir, stateManager, logger) {
                     timeoutMs: params.inheritedTimeoutMs,
                     inputArtifactRefs: [...params.inheritedInputArtifactRefs],
                     outputArtifactRefs: [],
+                    ...(params.ownerEvidenceSelection !== undefined
+                        ? { ownerEvidenceSelection: params.ownerEvidenceSelection }
+                        : {}),
                     repairPayload: params.repairPayload,
                 }),
             });

package/host-runtime/dist/production-pain-evidence.d.ts

@@ -143,6 +143,7 @@ export declare function createProductionPainEvidenceHandler(options?: {
     painEnrichmentProvider?: PainEnrichmentProvider;
     painDatabaseFactory?: PainDatabaseFactory;
     hostKind?: GovernanceHostKind;
+    projectDir?: string;
     events?: HostEventEmitter;
 }): (event: HostEvent) => Promise<HostEventResult>;
 export declare function resetProductionPainCooldownForTest(): void;

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

@@ -225,7 +225,7 @@ export function deriveProductionCorrectionPainIdentity(fields) {
 }
 const REQUIRED_COLUMNS = {
     sessions: { session_id: 'TEXT', started_at: 'TEXT', updated_at: 'TEXT' },
-    tool_calls: { session_id: 'TEXT', tool_name: 'TEXT', outcome: 'TEXT', duration_ms: 'INTEGER', exit_code: 'INTEGER', error_type: 'TEXT', error_message: 'TEXT', gfi_before: 'REAL', gfi_after: 'REAL', params_json: 'TEXT', result_preview: 'TEXT', created_at: 'TEXT' },
+    tool_calls: { session_id: 'TEXT', tool_name: 'TEXT', outcome: 'TEXT', duration_ms: 'INTEGER', exit_code: 'INTEGER', error_type: 'TEXT', error_message: 'TEXT', gfi_before: 'REAL', gfi_after: 'REAL', params_json: 'TEXT', result_preview: 'TEXT', created_at: 'TEXT', project_dir: 'TEXT' },
     pain_events: { session_id: 'TEXT', source: 'TEXT', score: 'REAL', reason: 'TEXT', severity: 'TEXT', origin: 'TEXT', confidence: 'REAL', text: 'TEXT', canonical_pain_id: 'TEXT', runtime_task_id: 'TEXT', host_kind: 'TEXT', created_at: 'TEXT' },
 };
 function pragmaField(row, key) {
@@ -277,7 +277,7 @@ function hasCanonicalSchema(db) {
     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 ?');
     db.prepare('SELECT 1 FROM pain_events WHERE canonical_pain_id = ?');
     db.prepare('INSERT INTO sessions (session_id, started_at, updated_at) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET updated_at = excluded.updated_at');
-    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) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
+    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) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
     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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
     return true;
 }
@@ -301,6 +301,19 @@ function ensureToolCallsToolUseIdColumn(db) {
         // the prepared-statement readiness check below fails loud if it is truly absent.
     }
 }
+/** Additive migration for verified host cwd binding; legacy rows stay NULL. */
+function ensureToolCallsProjectDirColumn(db) {
+    const columns = db.prepare('PRAGMA table_info(tool_calls)').all();
+    if (columns.some((row) => pragmaField(row, 'name') === 'project_dir'))
+        return;
+    try {
+        db.exec('ALTER TABLE tool_calls ADD COLUMN project_dir TEXT');
+    }
+    catch {
+        // A concurrent writer may have added it between the check and the ALTER;
+        // the prepared-statement readiness check below fails loud if absent.
+    }
+}
 /**
  * SPEC-CODEX-PAIN-CLOSURE-001 CR-01: upgrade the live-hook observation of a
  * tool call with the host-verified final result (exit code) read through the
@@ -412,6 +425,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
             db = options.painDatabaseFactory ? options.painDatabaseFactory(dbPath) : new Database(dbPath);
             db.pragma('busy_timeout = 5000');
             ensureToolCallsToolUseIdColumn(db);
+            ensureToolCallsProjectDirColumn(db);
             if (!hasCanonicalSchema(db)) {
                 db.close();
                 db = undefined;
@@ -518,8 +532,8 @@ export function createProductionPainEvidenceHandler(options = {}) {
                     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) 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);
+                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) 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));
                 if (admitted) {
                     // Raw observation only (Pain Diagnosis Persistence SPEC §8): the
                     // pain row must record WHAT happened, not WHY. Attribution

package/host-runtime/dist/production-rulehost-gate.d.ts

@@ -1,4 +1,4 @@
-import { type ToolSemanticRegistry } from '@principles/core/runtime-v2';
+import { type ToolSemanticRegistry, type GovernanceHostKind } from '@principles/core/runtime-v2';
 import type { HostEvent, HostEventResult } from '@principles/core/host';
 import { type RuleImplementationRuntime } from './rule-implementation-runtime.js';
 export interface ProductionRuleContextRequest {
@@ -17,6 +17,7 @@ export interface RuleInputEnrichment {
 export type RuleInputEnrichmentProvider = (request: ProductionRuleContextRequest) => unknown | Promise<unknown>;
 export interface ProductionRuleHostGateOptions {
     projectDir?: string;
+    hostKind?: GovernanceHostKind;
     ruleContextProvider?: RuleContextProvider;
     ruleInputEnrichmentProvider?: RuleInputEnrichmentProvider;
     implementationRuntime?: RuleImplementationRuntime;

package/host-runtime/dist/production-rulehost-gate.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { buildRuleHostAction, buildToolSemanticRegistry, deriveToolHintsFromCanonicalKind, estimateLineChanges, mergeDecisions, SqliteConnection, UNAVAILABLE_RULE_CONTEXT, validateRuleContextV2, validateRuleHostResult, verifyPiArtifactRowDigest, } from '@principles/core/runtime-v2';
+import { isSensitiveSystemPath } from '@principles/core/runtime-v2/internalization/rule-host-input-builder';
 import { scanRetiredContractSymbols } from './legacy-rule-contract-symbols.js';
 import { recordDegradedEnforcement } from './degraded-enforcement-marker.js';
 import { createNodeRuleImplementationRuntime, MAX_ACTIVE_RULES, RULE_BATCH_SOURCE_BYTES, RULE_SOURCE_BYTES, } from './rule-implementation-runtime.js';
@@ -174,6 +175,8 @@ export function createProductionRuleHostGate(options = {}) {
         SELECT a.activation_id, a.artifact_id, a.target_ref, a.action,
                c.enforcement, c.isolation_decision_id,
                p.source_rule_id, p.source_principle_id,
+               EXISTS (SELECT 1 FROM approvals ap WHERE ap.artifact_id = a.artifact_id
+                 AND ap.channel = 'code_tool_hook' AND ap.status = 'approved') AS owner_approved,
                length(CAST(p.content_json AS BLOB)) AS content_bytes,
                (SELECT d.artifact_digest FROM activation_decisions d
                 WHERE d.subject_kind = 'activation' AND d.activation_id = a.activation_id
@@ -232,8 +235,8 @@ export function createProductionRuleHostGate(options = {}) {
                     // through the SAME budget/content/context validation and
                     // evaluateBatch pipeline as live rows, but their results are
                     // collected as observations only and never join mergeDecisions
-                    // (shadow observes, never enforces). The v2 gate below stays ahead
-                    // of any evaluation, so Codex v2 shadow remains suspended.
+                    // (shadow observes, never enforces). The v2 qualification and context
+                    // checks below remain ahead of evaluation for both activation modes.
                     const activationMode = row.action === 'code_tool_hook_live_activate'
                         ? 'live'
                         : row.action === 'code_tool_hook_shadow_activate' ? 'shadow' : null;
@@ -325,6 +328,42 @@ export function createProductionRuleHostGate(options = {}) {
                                 addWarning(warnings, `unsupported_context_version: ${String(content.requiresContextVersion)}`, 'regenerate the rule artifact for context version 2');
                                 continue;
                             }
+                            // Codex V2 is opt-in per regenerated, Owner-approved artifact.
+                            // This system-stamped contract is emitted only after current
+                            // evaluator replay; merely wiring history must not revive old
+                            // activations. Live execution additionally needs the existing
+                            // promotion decision's binding to this exact artifact snapshot.
+                            if (options.hostKind === 'codex') {
+                                const contract = content.ruleHostInputContract;
+                                const hosts = isRecord(contract) ? contract.hostKinds : undefined;
+                                let contentBindingVerified = digestCheck.outcome === 'verified';
+                                if (activationMode === 'shadow' && row.owner_approved === 1) {
+                                    // Old databases remain readable without writing a migration
+                                    // from this enforcement reader. A legacy approval without a
+                                    // content digest cannot grant Codex V2 execution eligibility.
+                                    const approvalColumns = connection.getDb().prepare('PRAGMA table_info(approvals)').all();
+                                    if (approvalColumns.some((column) => isRecord(column) && column.name === 'artifact_digest')) {
+                                        const approval = connection.getDb().prepare(`
+                      SELECT artifact_digest FROM approvals
+                      WHERE artifact_id = ? AND channel = 'code_tool_hook' AND status = 'approved'
+                      ORDER BY decided_at DESC LIMIT 1
+                    `).get(artifactId);
+                                        const approvalDigest = isRecord(approval) && typeof approval.artifact_digest === 'string'
+                                            ? approval.artifact_digest : null;
+                                        contentBindingVerified = verifyPiArtifactRowDigest(contentRow, contentJson, approvalDigest).outcome === 'verified';
+                                    }
+                                    else {
+                                        contentBindingVerified = false;
+                                    }
+                                }
+                                if (!isRecord(contract) || contract.version !== 1 || contract.contextVersion !== 2
+                                    || !Array.isArray(hosts) || !hosts.every((host) => typeof host === 'string')
+                                    || !hosts.includes('codex') || row.owner_approved !== 1
+                                    || !contentBindingVerified) {
+                                    addWarning(warnings, `codex_rule_context_v2_unqualified: activation=${activationId}`, 'regenerate and replay this artifact for Codex, approve it for shadow observation, and use the existing Owner promotion flow for live execution');
+                                    continue;
+                                }
+                            }
                             // SPEC-RULECODE-QUALITY-001 A3 / §7.1 (Q10): MANDATORY runtime
                             // suspension of context-dependent rules. A v2 rule may only
                             // execute when the provider resolved a schema-valid context
@@ -379,7 +418,7 @@ export function createProductionRuleHostGate(options = {}) {
             }
             const hostInput = {
                 action,
-                workspace: { isRiskPath: false },
+                workspace: { isRiskPath: isSensitiveSystemPath(action.normalizedPath) },
                 session: { sessionId: event.context.sessionId, currentGfi: enrichment.currentGfi },
                 evolution: { epTier: enrichment.epTier },
                 derived: { estimatedLineChanges: estimateLineChanges({ toolName: input.toolName, params: input.params }), bashRisk: enrichment.bashRisk },
@@ -401,7 +440,9 @@ export function createProductionRuleHostGate(options = {}) {
             if (remaining <= 0) {
                 return { decision: 'allow', source: event.source, warnings: [boundedWarning('gate_deadline_exceeded', 'reduce active RuleCode count or source size and retry')], metadata: { evaluatedLiveRules: 0 } };
             }
-            const liveBatch = implementationRuntime.evaluateBatch(liveCandidates.map((candidate) => ({ source: candidate.source, filename: `activation-${candidate.implId}` })), hostInput, remaining);
+            const liveBatch = liveCandidates.length === 0
+                ? { ok: true, results: [] }
+                : implementationRuntime.evaluateBatch(liveCandidates.map((candidate) => ({ source: candidate.source, filename: `activation-${candidate.implId}` })), hostInput, remaining);
             if (!liveBatch.ok || !liveBatch.results) {
                 return { decision: 'allow', source: event.source, warnings: [boundedWarning(`${liveBatch.reason ?? 'rule_batch_failed'}: ${liveBatch.detail ?? 'unknown failure'}`, 'inspect active RuleCode resource use and repair or deactivate the unhealthy rule')], metadata: { evaluatedLiveRules: 0 } };
             }

package/host-runtime/dist/workspace-behavior-evidence.d.ts

@@ -1,3 +1,21 @@
 import type { BehaviorEvidencePort, ToolSemanticRegistry } from '@principles/core/runtime-v2';
+import type { RuleHostContextRow } from '@principles/core/trajectory-types';
 /** Lazy storage access: missing labels need no DB, and a failed open remains observable. */
 export declare function createWorkspaceBehaviorEvidencePort(workspaceDir: string, toolSemantics?: ToolSemanticRegistry): BehaviorEvidencePort;
+/**
+ * Read one bounded, same-session history window from the canonical trajectory
+ * database. The timestamp is the caller's pre-event cutoff; rows at or after
+ * it are excluded so replayed/future calls cannot enter a live RuleContext.
+ * This is read-only and never creates or migrates trajectory state.
+ */
+export declare function readWorkspaceRuleContextRowsBefore(workspaceDir: string, input: {
+    sessionId: string;
+    projectDir: string;
+    beforeCreatedAt: string;
+    excludeToolUseId: string;
+    limit: number;
+}): {
+    rows: readonly RuleHostContextRow[];
+    truncated: boolean;
+    unscopedPriorRows: boolean;
+};

package/host-runtime/dist/workspace-behavior-evidence.js

@@ -72,3 +72,50 @@ export function createWorkspaceBehaviorEvidencePort(workspaceDir, toolSemantics)
         },
     };
 }
+/**
+ * Read one bounded, same-session history window from the canonical trajectory
+ * database. The timestamp is the caller's pre-event cutoff; rows at or after
+ * it are excluded so replayed/future calls cannot enter a live RuleContext.
+ * This is read-only and never creates or migrates trajectory state.
+ */
+export function readWorkspaceRuleContextRowsBefore(workspaceDir, input) {
+    const { sessionId, projectDir, beforeCreatedAt, excludeToolUseId, limit } = input;
+    if (sessionId.trim().length === 0)
+        throw new Error('history_session_id_invalid');
+    if (!path.isAbsolute(projectDir))
+        throw new Error('history_project_dir_invalid');
+    if (excludeToolUseId.trim().length === 0)
+        throw new Error('history_tool_use_id_invalid');
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
+        throw new Error('history_limit_invalid');
+    if (!Number.isFinite(Date.parse(beforeCreatedAt)))
+        throw new Error('history_cutoff_invalid');
+    const db = new Database(path.join(workspaceDir, '.state', 'trajectory.db'), { readonly: true, fileMustExist: true });
+    try {
+        db.pragma('busy_timeout = 100');
+        return db.transaction(() => {
+            const rows = db.prepare(`
+        SELECT id, tool_name, outcome, params_json
+        FROM tool_calls
+        WHERE session_id = ? AND project_dir = ? AND created_at < ? AND (tool_use_id IS NULL OR tool_use_id <> ?)
+        ORDER BY created_at DESC, id DESC
+        LIMIT ?
+      `).all(sessionId, projectDir, beforeCreatedAt, excludeToolUseId, limit + 1);
+            const unscoped = db.prepare(`
+        SELECT 1 AS found FROM tool_calls
+        WHERE session_id = ? AND project_dir IS NULL AND created_at < ?
+          AND (tool_use_id IS NULL OR tool_use_id <> ?) LIMIT 1
+      `).get(sessionId, beforeCreatedAt, excludeToolUseId);
+            if (!Array.isArray(rows))
+                throw new Error('history_query_invalid');
+            return {
+                rows: rows.slice(0, limit).reverse().map(contextRow),
+                truncated: rows.length > limit,
+                unscopedPriorRows: unscoped !== undefined,
+            };
+        })();
+    }
+    finally {
+        db.close();
+    }
+}

package/host-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/host-runtime",
-  "version": "0.10.2",
+  "version": "0.10.4",
   "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.145.8",
+  "version": "1.145.10",
   "description": "Interactive CLI installer for Principles Disciple OpenClaw plugin",
   "type": "module",
   "bin": {

package/pd-cli/dist/commands/runtime-internalization-run-once.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime-internalization-run-once.d.ts","sourceRoot":"","sources":["../../src/commands/runtime-internalization-run-once.ts"],"names":[],"mappings":"AA4CA,UAAU,cAAc;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAyXD,wBAAsB,mCAAmC,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA4Y7F"}
+{"version":3,"file":"runtime-internalization-run-once.d.ts","sourceRoot":"","sources":["../../src/commands/runtime-internalization-run-once.ts"],"names":[],"mappings":"AA4CA,UAAU,cAAc;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAkZD,wBAAsB,mCAAmC,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CA4Y7F"}

package/pd-cli/dist/commands/runtime-internalization-run-once.js

@@ -166,7 +166,22 @@ function buildTestDoubleAdapter(runnerKind, taskId) {
         });
     }
     if (runnerKind === 'scribe') {
+        let capturedSourcePhilosopherArtifactId = '';
         return new TestDoubleRuntimeAdapter({
+            onStartRun: (input) => {
+                try {
+                    const payloadStr = typeof input.inputPayload === 'string' ? input.inputPayload : JSON.stringify(input.inputPayload);
+                    const parsed = JSON.parse(payloadStr);
+                    if (typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)) {
+                        const sourceId = Reflect.get(parsed, 'sourcePhilosopherArtifactId');
+                        if (typeof sourceId === 'string' && sourceId.trim() !== '') {
+                            capturedSourcePhilosopherArtifactId = sourceId;
+                        }
+                    }
+                }
+                catch { /* empty lineage fails the strict Scribe validator */ }
+                return { runId: `td-scribe-${Date.now()}`, runtimeKind: 'test-double', startedAt: new Date().toISOString() };
+            },
             onPollRun: (_runId) => ({
                 runId: _runId,
                 status: 'succeeded',
@@ -177,17 +192,28 @@ function buildTestDoubleAdapter(runnerKind, taskId) {
                 runId: _runId,
                 payload: {
                     taskId,
-                    sourcePhilosopherArtifactId: 'pi-art-test-philosopher',
+                    sourcePhilosopherArtifactId: capturedSourcePhilosopherArtifactId,
                     principleDraft: {
                         title: 'Test Principle Draft',
-                        statement: 'Test principle statement',
-                        rationale: 'Test rationale',
-                        applicability: ['All operations'],
-                        antiPatterns: ['Ignoring validation'],
+                        statement: 'Before changing a system, verify the current requirement and affected behavior; do not act on unverified assumptions.',
+                        rationale: 'Checking the stated requirement and affected behavior prevents avoidable changes based on assumptions.',
+                        applicability: ['Changes to an existing system'],
+                        antiPatterns: ['Making changes based only on an unverified assumption'],
                         confidence: 0.8,
                     },
+                    intentContract: {
+                        ownerIntent: 'Preserve the stated requirement while making changes.',
+                        targetBehavior: 'Before changing a system, verify the current requirement and affected behavior.',
+                        forbiddenBehavior: 'Do not make changes based only on an unverified assumption.',
+                        evidenceSource: 'The source Philosopher principle draft and rationale.',
+                        validationExpectation: 'The proposed change is checked against the stated requirement and affected behavior.',
+                    },
+                    // This fixture's principle requires no trusted external facts; the
+                    // explicit empty declaration keeps the test double aligned with the
+                    // strict new-generation contract without weakening production validation.
+                    executionConditions: { version: 1, requiredFacts: [] },
                     sourceTrace: {
-                        philosopherArtifactId: 'pi-art-test-philosopher',
+                        philosopherArtifactId: capturedSourcePhilosopherArtifactId,
                     },
                     risks: [],
                     generatedAt: new Date().toISOString(),
@@ -517,7 +543,7 @@ export async function handleRuntimeInternalizationRunOnce(opts) {
                     runnerResult = await runner.run(wakeResult.taskId);
                 }
                 else if (runnerKind === 'scribe') {
-                    const validator = new DefaultScribeValidator();
+                    const validator = new DefaultScribeValidator({ requireRuleCodeContracts: true });
                     const runner = new ScribeRunner({
                         stateManager, runtimeAdapter, eventEmitter, validator, artifactStore,
                         // I2 — CHAIN STAMPING (Owner review of PR #1856, P1): stamp the