create-principles-disciple 1.144.26 → 1.145.0

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

@@ -85,6 +85,37 @@ async function safeRunRecoverySweep(stateManager, ports) {
  * - P1: 任何 reconcile_error 显式留痕 (不依赖 recovered>0)。
  */
 const RECONCILIATION_BUDGET = 5;
+/**
+ * PRI-954 (F10) oldest-ready-stage-first ordering. Returns the configured
+ * runner kinds reordered to start at the stage that owns the globally oldest
+ * ready task (by `createdAt`); later stages keep their relative priority
+ * order, so dependency order inside one stage scan is untouched. Tasks
+ * without a readable createdAt sort last for ordering purposes (their stage
+ * keeps the default position) — unknown age never jumps the queue.
+ */
+export function orderKindsByOldestReadyStage(runnerKinds, readyTasks) {
+    if (runnerKinds.length <= 1 || readyTasks.length === 0)
+        return [...runnerKinds];
+    const priorityIndex = new Map(runnerKinds.map((k, i) => [k, i]));
+    let oldest = null;
+    for (const task of readyTasks) {
+        if (typeof task.createdAt !== 'string' || task.createdAt.length === 0)
+            continue;
+        const index = priorityIndex.get(task.taskKind);
+        if (index === undefined)
+            continue; // stage outside this consumer's scope
+        if (oldest === null ||
+            task.createdAt < oldest.createdAt ||
+            (task.createdAt === oldest.createdAt && index < oldest.index)) {
+            oldest = { taskKind: task.taskKind, createdAt: task.createdAt, index };
+        }
+    }
+    const startKind = oldest?.taskKind;
+    const startIndex = startKind !== undefined ? runnerKinds.indexOf(startKind) : -1;
+    if (startIndex <= 0)
+        return [...runnerKinds];
+    return [...runnerKinds.slice(startIndex), ...runnerKinds.slice(0, startIndex)];
+}
 async function runReconciliationBudget(workspaceDir, orchestrator, ports) {
     const { logger, emitEvent, logLabel } = ports;
     try {
@@ -254,7 +285,18 @@ export async function runInternalizationConsumerCycle(workspaceDir, ports) {
         let lastSkipDecision = 'no_ready_tasks';
         let lastSkipReason;
         let taskRuntimeConfig = null;
-        for (const kind of decision.runnerKinds) {
+        // PRI-954 (F10): oldest-ready-stage-first fairness. The fixed dreamer-first
+        // order plus one-task-per-cycle let a continuous stream of new dreamer
+        // tasks (each real Pain creates one) keep downstream stages waiting for an
+        // unbounded number of cycles — measured at 35+ minutes of philosopher
+        // starvation under sustained load (2026-10-13 dogfood, findings F10).
+        // Starting the stage scan at the stage owning the GLOBALLY OLDEST ready
+        // task bounds every stage's wait without concurrency, without persisted
+        // scheduler state (works across one-shot `--once` worker processes), and
+        // without touching leases, idempotency, dependency order, or the
+        // single-task-per-cycle semantics. Ties keep the original priority order.
+        const orderedRunnerKinds = orderKindsByOldestReadyStage(decision.runnerKinds, snapshot.readyTasks);
+        for (const kind of orderedRunnerKinds) {
             const agentName = AGENT_NAME_FOR_TASK_KIND[kind];
             if (agentName === undefined) {
                 lastSkipDecision = 'runtime_config_error';

package/host-runtime/dist/intervention-evidence-ingress.d.ts

@@ -8,7 +8,7 @@ export interface InterventionIngressAppendResult {
     nextAction?: string;
 }
 export interface ExistingInterventionObservationSource {
-    sourceKind: 'openclaw_plugin_event_log' | 'codex_pd_hook_event_log';
+    sourceKind: 'openclaw_plugin_event_log' | 'codex_pd_hook_event_log' | 'workbuddy_pd_hook_event_log';
     sourceLocator: string;
     observationKey: string;
     principleId: string;

package/host-runtime/dist/product-telemetry/service.js

@@ -193,7 +193,7 @@ function resolveInstallContext(homeDir) {
     const legacyExtensionExists = fs.existsSync(paths.openClawExtensionDir);
     const layout = resolveInstallLayout({ homeDir, manifest, canonicalRuntimeExists, legacyExtensionExists });
     let hostKind = 'other';
-    if (manifest && manifest.hosts.length === 1 && (manifest.hosts[0] === 'codex' || manifest.hosts[0] === 'openclaw')) {
+    if (manifest && manifest.hosts.length === 1 && (manifest.hosts[0] === 'codex' || manifest.hosts[0] === 'openclaw' || manifest.hosts[0] === 'workbuddy')) {
         [hostKind] = manifest.hosts;
     }
     else if (legacyExtensionExists) {

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

@@ -19,9 +19,14 @@ export interface ProductionPainEnrichment {
 }
 export type PainEnrichmentProvider = (event: HostEvent) => unknown | Promise<unknown>;
 export type PainDatabaseFactory = (databasePath: string) => Database.Database;
+/** SPEC-CODEX-PAIN-CLOSURE-001 CR-01: a tool result is success, failure or unknown. */
+export type ToolOutcomeClassification = 'success' | 'failure' | 'unknown';
 interface NormalizedOutcome {
+    outcome: ToolOutcomeClassification;
     failure: boolean;
-    exitCode: number;
+    exitCode: number | null;
+    /** Bounded structured reason present when the outcome is unknown (rc-9). */
+    unknownReason?: string;
     error?: string;
     durationMs?: number;
     params: unknown;
@@ -32,6 +37,16 @@ export interface ProductionToolEventFields {
     workspaceDir: string;
     sessionId: string;
     turnId?: string;
+    /**
+     * I1: the host's real per-call identity (Codex `tool_use_id`, WorkBuddy
+     * `call_id`). Two calls with the same session/generation/tool/params/result
+     * but DIFFERENT call ids are two real occurrences and must derive two
+     * identities; a redelivery of the SAME call id is one occurrence. Optional:
+     * hosts that supply no call id keep the historical content-derived identity
+     * (identical-content calls then cannot be distinguished — a documented
+     * limitation, never fabricated precision).
+     */
+    toolCallId?: string;
     toolName?: string;
     toolInput?: unknown;
     toolOutput?: unknown;
@@ -51,6 +66,11 @@ export interface DerivedToolPainIdentity {
  * fields fed to the live production handler derive the same deterministic
  * `pain_host_<sha256>` id, so live and observation-delivered admissions of one
  * tool call converge on one canonical pain.
+ *
+ * I1 parity obligation: when the host supplies a call id, BOTH paths must pass
+ * the same `toolCallId` (Codex admission candidates carry it from the same
+ * `tool_use_id` the live decoder required) — otherwise one real call would
+ * derive two canonical pains.
  */
 export declare function deriveProductionToolPainIdentity(fields: ProductionToolEventFields & {
     canonicalEventId?: string;
@@ -76,6 +96,44 @@ export declare function deriveProductionCorrectionPainIdentity(fields: {
     painId: string;
 };
 declare function hasCanonicalSchema(db: Database.Database): boolean;
+/** One host-verified tool outcome (SPEC-CODEX-PAIN-CLOSURE-001 CR-01). */
+export interface VerifiedToolOutcomeInput {
+    /** Host tool-call id — the join key written by the live PostToolUse path. */
+    readonly toolUseId: string;
+    readonly toolName: string;
+    readonly params?: unknown;
+    /** Verified process exit code from the host's authoritative tool-fact record. */
+    readonly exitCode: number;
+    readonly outputPreview?: string;
+}
+export type VerifiedToolOutcomeStatus = {
+    status: 'updated';
+    id: number;
+} | {
+    status: 'inserted';
+    id: number;
+} | {
+    status: 'skipped_final';
+    id: number;
+    reason: 'outcome_already_final';
+} | {
+    status: 'unavailable';
+    reason: 'trajectory_db_not_found' | 'trajectory_write_failed' | `trajectory_write_failed:${string}`;
+};
+/**
+ * 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
+ * existing authorized transcript-facts path. Only rows still recorded as
+ * `unknown` (text-only live response) are upgraded — a structured live fact
+ * is never overwritten. Missing live rows are inserted so the verified fact
+ * is durable even when the live hook never fired.
+ */
+export declare function recordVerifiedToolOutcomes(args: {
+    workspaceDir: string;
+    sessionId: string;
+    outcomes: readonly VerifiedToolOutcomeInput[];
+    painDatabaseFactory?: PainDatabaseFactory;
+}): VerifiedToolOutcomeStatus[];
 /**
  * PRI-640: host attribution is supplied by the host adapter that constructs
  * this shared handler (OpenClaw / Codex adapters) — never guessed inside the

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

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import Database from 'better-sqlite3';
-import { buildToolFailureObservation, evaluateTriage, evaluateTriggerController, resolveSourceKind, sanitizeToolParams, sanitizeValue, } from '@principles/core/runtime-v2';
+import { applyTrajectorySchemaBase, buildToolFailureObservation, evaluateTriage, evaluateTriggerController, resolveSourceKind, sanitizeToolParams, sanitizeValue, } from '@principles/core/runtime-v2';
 const WRITE_TOOLS = new Set(['write', 'edit', 'apply_patch', 'write_file', 'edit_file', 'replace']);
 /** Shared with the governance admission path so both gate tool failures identically. */
 export const PRODUCTION_WRITE_TOOLS = WRITE_TOOLS;
@@ -17,19 +17,62 @@ function field(value, key) {
         return undefined;
     return Object.getOwnPropertyDescriptor(value, key)?.value;
 }
+/**
+ * SPEC-CODEX-PAIN-CLOSURE-001 CR-01 (PRI-960): classify a tool result as
+ * success / failure / unknown from structured facts only — a missing exit
+ * code must never become a fabricated 0, and text-only responses must never
+ * be guessed into success or failure by keyword scanning.
+ *
+ * Verified Codex facts (codex-rs core/src/tools/context.rs): PostToolUse
+ * `tool_response` for the shell tool is a plain string (the truncated output
+ * text); the exit code is only published to the transcript CommandExecution
+ * record. Plain-text responses therefore classify as unknown here and are
+ * upgraded later by the consent-gated transcript path (recordVerifiedToolOutcomes).
+ *
+ * Structured read tools (object/array results without an error field) are a
+ * legitimate completion of the tool contract and stay success (SPEC §5.1).
+ */
 function normalizeOutcome(event) {
     const context = 'context' in event ? event.context : event;
     const envelope = context.toolOutput;
     const result = field(envelope, 'result') ?? envelope;
-    const errorValue = field(envelope, 'error');
-    const resultExit = field(result, 'exitCode');
-    const detailsExit = field(field(result, 'details'), 'exitCode');
-    const exitCode = typeof resultExit === 'number' ? resultExit : typeof detailsExit === 'number' ? detailsExit : 0;
+    const errorValue = field(envelope, 'error') ?? field(result, 'error');
     const error = errorValue === undefined || errorValue === null || errorValue === '' ? undefined : String(errorValue);
+    // Exit-code candidates: camelCase AND snake_case at the envelope, result,
+    // details and metadata levels (Codex transcript facts arrive snake_case).
+    const exitCandidates = [
+        field(envelope, 'exitCode'), field(envelope, 'exit_code'),
+        field(result, 'exitCode'), field(result, 'exit_code'),
+        field(field(result, 'details'), 'exitCode'), field(field(result, 'details'), 'exit_code'),
+        field(field(result, 'metadata'), 'exitCode'), field(field(result, 'metadata'), 'exit_code'),
+    ];
+    const exitCandidate = exitCandidates.find((value) => typeof value === 'number' && Number.isInteger(value));
+    const exitCode = typeof exitCandidate === 'number' ? exitCandidate : null;
     const durationValue = field(envelope, 'durationMs');
+    let outcome;
+    let unknownReason;
+    if (error !== undefined) {
+        outcome = 'failure';
+    }
+    else if (exitCode !== null) {
+        outcome = exitCode === 0 ? 'success' : 'failure';
+    }
+    else if (typeof envelope === 'string' || typeof result === 'string') {
+        outcome = 'unknown';
+        unknownReason = 'text_only_response';
+    }
+    else if (isRecord(envelope) || Array.isArray(envelope)) {
+        outcome = 'success';
+    }
+    else {
+        outcome = 'unknown';
+        unknownReason = 'unconfirmed_result_shape';
+    }
     return {
-        failure: error !== undefined || exitCode !== 0,
+        outcome,
+        failure: outcome === 'failure',
         exitCode,
+        ...(unknownReason !== undefined ? { unknownReason } : {}),
         ...(error ? { error: error.slice(0, MAX_PREVIEW) } : {}),
         ...(typeof durationValue === 'number' && Number.isFinite(durationValue) && durationValue >= 0 ? { durationMs: durationValue } : {}),
         params: context.toolInput ?? {},
@@ -104,6 +147,9 @@ function preview(value) {
 }
 function ids(input) {
     const { outcome, sanitizedParams, canonicalEventId } = input;
+    // The toolCallId key is included ONLY when the host supplied one, so the
+    // canonical string of a no-call-id host is byte-identical to the historical
+    // derivation (persisted rows stay replay-stable across the upgrade).
     const canonical = stable({
         workspaceDir: path.resolve(input.workspaceDir),
         sessionId: input.sessionId,
@@ -111,6 +157,7 @@ function ids(input) {
         toolName: input.toolName,
         source: input.source,
         suppliedEventId: canonicalEventId ?? null,
+        ...(input.toolCallId !== undefined ? { toolCallId: input.toolCallId } : {}),
         params: sanitizedParams,
         result: sanitizeValue(outcome.result, 0, input.workspaceDir),
         error: outcome.error ?? null,
@@ -126,6 +173,11 @@ function ids(input) {
  * fields fed to the live production handler derive the same deterministic
  * `pain_host_<sha256>` id, so live and observation-delivered admissions of one
  * tool call converge on one canonical pain.
+ *
+ * I1 parity obligation: when the host supplies a call id, BOTH paths must pass
+ * the same `toolCallId` (Codex admission candidates carry it from the same
+ * `tool_use_id` the live decoder required) — otherwise one real call would
+ * derive two canonical pains.
  */
 export function deriveProductionToolPainIdentity(fields) {
     const outcome = normalizeOutcome(fields);
@@ -137,6 +189,7 @@ export function deriveProductionToolPainIdentity(fields) {
         ...(fields.toolName !== undefined ? { toolName: fields.toolName } : {}),
         source: fields.source,
         ...(fields.canonicalEventId !== undefined ? { canonicalEventId: fields.canonicalEventId } : {}),
+        ...(fields.toolCallId !== undefined ? { toolCallId: fields.toolCallId } : {}),
         outcome,
         sanitizedParams,
     });
@@ -220,13 +273,107 @@ function hasCanonicalSchema(db) {
         return false;
     // Preparing the exact production statements proves syntax/column readiness
     // without executing mutation or invoking host enrichment side effects.
+    db.prepare('SELECT 1 FROM tool_calls WHERE session_id = ? AND tool_use_id = ?');
     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) 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) 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;
 }
+/**
+ * SPEC-CODEX-PAIN-CLOSURE-001 CR-01: additive migration for the host
+ * tool-call id join column. The schema-owning modules (trajectory-schema.ts
+ * applyTrajectorySchemaBase) add it for every fresh/managed open; this local
+ * ensure covers the raw production-handler open, which historically opens
+ * trajectory.db without running the schema apply.
+ */
+function ensureToolCallsToolUseIdColumn(db) {
+    const columns = db.prepare('PRAGMA table_info(tool_calls)').all();
+    if (columns.some((row) => pragmaField(row, 'name') === 'tool_use_id'))
+        return;
+    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 {
+        // A concurrent writer may have added it between the check and the ALTER;
+        // the prepared-statement readiness check below fails loud if it is truly 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
+ * existing authorized transcript-facts path. Only rows still recorded as
+ * `unknown` (text-only live response) are upgraded — a structured live fact
+ * is never overwritten. Missing live rows are inserted so the verified fact
+ * is durable even when the live hook never fired.
+ */
+export function recordVerifiedToolOutcomes(args) {
+    const results = [];
+    if (args.outcomes.length === 0)
+        return results;
+    const dbPath = path.join(args.workspaceDir, '.state', 'trajectory.db');
+    if (!fs.existsSync(dbPath)) {
+        return args.outcomes.map(() => ({ status: 'unavailable', reason: 'trajectory_db_not_found' }));
+    }
+    let db;
+    try {
+        db = args.painDatabaseFactory ? args.painDatabaseFactory(dbPath) : new Database(dbPath);
+        db.pragma('busy_timeout = 5000');
+        // Workspaces whose trajectory.db only ever carried the governance tables
+        // (no live PostToolUse writer ran yet) lack tool_calls: apply the one
+        // canonical base schema before upgrading (idempotent, DDL authority stays
+        // with core's trajectory-schema).
+        const hasToolCalls = (db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'tool_calls'").get() !== undefined);
+        if (!hasToolCalls)
+            applyTrajectorySchemaBase(db);
+        ensureToolCallsToolUseIdColumn(db);
+        const findByToolUseId = db.prepare('SELECT id, outcome FROM tool_calls WHERE session_id = ? AND tool_use_id = ? ORDER BY id LIMIT 1');
+        const upgradeUnknown = db.prepare("UPDATE tool_calls SET outcome = ?, exit_code = ?, result_preview = COALESCE(?, result_preview) WHERE id = ? AND outcome = 'unknown'");
+        const insertVerified = 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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)');
+        const upsertSession = db.prepare('INSERT INTO sessions (session_id, started_at, updated_at) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET updated_at = excluded.updated_at');
+        const createdAt = new Date().toISOString();
+        db.transaction(() => {
+            for (const input of args.outcomes) {
+                if (typeof input.exitCode !== 'number' || !Number.isInteger(input.exitCode))
+                    continue;
+                const finalOutcome = input.exitCode === 0 ? 'success' : 'failure';
+                const existing = findByToolUseId.get(args.sessionId, input.toolUseId);
+                const boundedPreview = typeof input.outputPreview === 'string' && input.outputPreview.length > 0
+                    ? input.outputPreview.slice(0, MAX_PREVIEW)
+                    : null;
+                if (existing !== undefined) {
+                    if (existing.outcome === 'unknown') {
+                        upgradeUnknown.run(finalOutcome, input.exitCode, boundedPreview, existing.id);
+                        results.push({ status: 'updated', id: existing.id });
+                    }
+                    else {
+                        results.push({ status: 'skipped_final', id: existing.id, reason: 'outcome_already_final' });
+                    }
+                    continue;
+                }
+                upsertSession.run(args.sessionId, createdAt, createdAt);
+                const sanitizedParams = sanitizeToolParams(input.params ?? {}, args.workspaceDir);
+                const info = insertVerified.run(args.sessionId, input.toolName, finalOutcome, null, input.exitCode, null, null, null, null, stable(sanitizedParams), boundedPreview, createdAt, input.toolUseId);
+                results.push({ status: 'inserted', id: Number(info.lastInsertRowid) });
+            }
+        })();
+    }
+    catch (error) {
+        const reason = `trajectory_write_failed:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`;
+        const filled = results.length;
+        for (let i = filled; i < args.outcomes.length; i += 1)
+            results.push({ status: 'unavailable', reason });
+    }
+    finally {
+        try {
+            db?.close();
+        }
+        catch { /* write result already determined; cleanup is best-effort */ }
+    }
+    return results;
+}
 /**
  * PRI-640: host attribution is supplied by the host adapter that constructs
  * this shared handler (OpenClaw / Codex adapters) — never guessed inside the
@@ -248,7 +395,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
             options.events?.recordToolCall(event.context.sessionId, {
                 toolName: event.context.toolName ?? '',
                 ...(earlyOutcome.error ? { error: earlyOutcome.error } : {}),
-                ...(earlyOutcome.exitCode !== 0 ? { exitCode: earlyOutcome.exitCode } : {}),
+                ...(earlyOutcome.exitCode !== null && earlyOutcome.exitCode !== 0 ? { exitCode: earlyOutcome.exitCode } : {}),
                 ...(event.context.turnId !== undefined ? { runId: event.context.turnId } : {}),
                 ...(event.context.toolCallId !== undefined ? { toolCallId: event.context.toolCallId } : {}),
             });
@@ -264,6 +411,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
         try {
             db = options.painDatabaseFactory ? options.painDatabaseFactory(dbPath) : new Database(dbPath);
             db.pragma('busy_timeout = 5000');
+            ensureToolCallsToolUseIdColumn(db);
             if (!hasCanonicalSchema(db)) {
                 db.close();
                 db = undefined;
@@ -296,22 +444,43 @@ export function createProductionPainEvidenceHandler(options = {}) {
         const outcome = normalizeOutcome(event);
         const sanitizedParams = sanitizeToolParams(outcome.params, event.context.workspaceDir);
         const toolName = event.context.toolName ?? '';
-        const sourceObservation = buildToolFailureObservation({ toolName, error: outcome.error, exitCode: outcome.exitCode });
+        const sourceObservation = buildToolFailureObservation({ toolName, error: outcome.error, exitCode: outcome.exitCode ?? undefined });
+        const nonZeroExit = outcome.exitCode !== null && outcome.exitCode !== 0;
         const sourceKind = resolveSourceKind({
             observedAt: new Date().toISOString(), workspaceId: event.context.workspaceDir,
             sessionId: event.context.sessionId, toolName, failureSource: sourceObservation.failureSource,
-            toolNotFound: sourceObservation.toolNotFound, nonZeroExit: outcome.exitCode !== 0,
+            toolNotFound: sourceObservation.toolNotFound, nonZeroExit,
         });
         const relativePath = enrichment.relativePath ?? String(field(outcome.params, 'file_path') ?? field(outcome.params, 'path') ?? 'unknown').slice(0, 500);
         const isRisky = enrichment.isRisky ?? (path.isAbsolute(relativePath) && !path.resolve(relativePath).startsWith(`${path.resolve(event.context.workspaceDir)}${path.sep}`));
-        const painScore = enrichment.painScore ?? Math.min(100, (outcome.exitCode !== 0 ? 70 : 0) + (isRisky ? 20 : 0));
+        // Merged scoring semantics (WorkBuddy admission floor × CR-01): the 70
+        // failure base requires a VERIFIED non-zero exit code (branch review
+        // round: a thrown error with no exit evidence stays at the risky-path
+        // bonus only, honestly below the GOVERNANCE_STRONG_PAIN_SCORE floor, so
+        // unverified error shapes never spawn diagnostician work on their own).
+        // Classification and RECORDING remain main's three-way contract — the
+        // row still records outcome='failure' with exit_code NULL (never a
+        // fabricated 0).
+        const verifiedNonZeroExit = outcome.exitCode !== null && outcome.exitCode !== 0;
+        const painScore = enrichment.painScore ?? Math.min(100, (verifiedNonZeroExit ? 70 : 0) + (isRisky ? 20 : 0));
         const errorHash = enrichment.errorHash ?? createHash('sha256').update(outcome.error ?? String(outcome.exitCode)).digest('hex');
+        // Cooldown is DEBOUNCE, not event identity (I1): the key deliberately has
+        // NO toolCallId. Repeated failures of the same failureSource+error within
+        // the window suppress the diagnostic trigger storm, while each real call
+        // still earns its own tool_calls evidence row through call-id-sensitive
+        // identity below.
         const cooldownKey = `${path.resolve(event.context.workspaceDir)}:${event.context.sessionId}:${sourceObservation.failureSource}:${errorHash}`;
         const last = cooldowns.get(cooldownKey);
         const cooldownActive = last !== undefined && Date.now() - last < PAIN_COOLDOWN_WINDOW_MS;
         const triage = evaluateTriage({ sourceKind, score: painScore, consecutiveErrors: enrichment.consecutiveErrors, isRisky });
         const trigger = evaluateTriggerController({ triageResult: triage, isOwnerManual: false, isCooldownActive: cooldownActive, isValid: true, score: painScore, sessionId: event.context.sessionId });
-        const admitted = outcome.failure && WRITE_TOOLS.has(toolName) && trigger.shouldCreateDiagnosticTask;
+        // Merged semantics (WorkBuddy × CR-01): the three-way classification from
+        // SPEC-CODEX-PAIN-CLOSURE-001 gates admission ('unknown' results are never
+        // pain), and WorkBuddy tool names are capitalized (Write/Edit — probe P03)
+        // while OpenClaw/Codex are lowercase; admission is about the tool FAMILY,
+        // so compare case-insensitively at this one boundary. tool_calls evidence
+        // above keeps the raw host name.
+        const admitted = outcome.outcome === 'failure' && WRITE_TOOLS.has(toolName.toLowerCase()) && trigger.shouldCreateDiagnosticTask;
         const { eventId, painId } = ids({
             workspaceDir: event.context.workspaceDir,
             sessionId: event.context.sessionId,
@@ -319,6 +488,11 @@ export function createProductionPainEvidenceHandler(options = {}) {
             ...(toolName !== undefined ? { toolName } : {}),
             source: event.source,
             ...(enrichment.eventId ? { canonicalEventId: enrichment.eventId } : {}),
+            // I1: the host's real call identity participates when supplied —
+            // distinct call ids are distinct events; a same-call-id redelivery
+            // derives the same identity and stays idempotent. Absent → historical
+            // content-derived identity (no fabricated precision).
+            ...(event.context.toolCallId !== undefined ? { toolCallId: event.context.toolCallId } : {}),
             outcome,
             sanitizedParams,
         });
@@ -329,14 +503,23 @@ export function createProductionPainEvidenceHandler(options = {}) {
         let duplicateAdmitted = false;
         try {
             db.transaction(() => {
-                if (db.prepare('SELECT 1 FROM tool_calls WHERE session_id = ? AND tool_name = ? AND params_json = ? AND outcome = ? AND exit_code IS ? AND error_message IS ? AND result_preview IS ?').get(event.context.sessionId, toolName, paramsJson, outcome.failure ? 'failure' : 'success', outcome.exitCode, outcome.error ?? null, resultPreview)) {
+                // CR-01: the host tool-call id is the stable join key for the
+                // consent-gated transcript upgrade (recordVerifiedToolOutcomes);
+                // content-shape probing stays the fallback for hosts without ids.
+                if (event.context.toolCallId !== undefined
+                    && db.prepare('SELECT 1 FROM tool_calls WHERE session_id = ? AND tool_use_id = ?').get(event.context.sessionId, event.context.toolCallId) !== undefined) {
+                    duplicate = true;
+                    duplicateAdmitted = db.prepare('SELECT 1 FROM pain_events WHERE canonical_pain_id = ?').get(painId) !== undefined;
+                    return;
+                }
+                if (db.prepare('SELECT 1 FROM tool_calls WHERE session_id = ? AND tool_name = ? AND params_json = ? AND outcome = ? AND exit_code IS ? AND error_message IS ? AND result_preview IS ?').get(event.context.sessionId, toolName, paramsJson, outcome.outcome, outcome.exitCode, outcome.error ?? null, resultPreview)) {
                     duplicate = true;
                     duplicateAdmitted = db.prepare('SELECT 1 FROM pain_events WHERE canonical_pain_id = ?').get(painId) !== undefined;
                     return;
                 }
                 db.prepare(`INSERT INTO sessions (session_id, started_at, updated_at) VALUES (?, ?, ?) ON CONFLICT(session_id) DO UPDATE SET updated_at = excluded.updated_at`).run(event.context.sessionId, createdAt, createdAt);
-                db.prepare(`INSERT INTO tool_calls (session_id, tool_name, outcome, duration_ms, exit_code, error_type, error_message, gfi_before, gfi_after, params_json, result_preview, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
-                    .run(event.context.sessionId, toolName, outcome.failure ? 'failure' : 'success', outcome.durationMs ?? null, outcome.exitCode, outcome.error ? outcome.error.split(/[\s:]/, 1)[0] : null, outcome.error ?? null, null, null, paramsJson, resultPreview, 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);
                 if (admitted) {
                     // Raw observation only (Pain Diagnosis Persistence SPEC §8): the
                     // pain row must record WHAT happened, not WHY. Attribution
@@ -364,7 +547,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
             }
         }
         catch (error) {
-            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), `trajectory_write_failed:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: outcome.failure ? 'failure' : 'success', admitted: false, duplicate: false, nextAction: 'inspect the workspace trajectory database and retry' } };
+            return { decision: 'observe', source: event.source, warnings: [...(emissionWarning ? [emissionWarning] : []), `trajectory_write_failed:${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`], metadata: { outcome: outcome.outcome, admitted: false, duplicate: false, nextAction: 'inspect the workspace trajectory database and retry' } };
         }
         finally {
             try {
@@ -378,7 +561,7 @@ export function createProductionPainEvidenceHandler(options = {}) {
             source: event.source,
             ...(emissionWarning ? { warnings: [emissionWarning] } : {}),
             metadata: {
-                eventId, painId: effectiveAdmitted ? painId : null, outcome: outcome.failure ? 'failure' : 'success', admitted: effectiveAdmitted, duplicate,
+                eventId, painId: effectiveAdmitted ? painId : null, outcome: outcome.outcome, ...(outcome.unknownReason !== undefined ? { outcomeReason: outcome.unknownReason } : {}), exitCode: outcome.exitCode, admitted: effectiveAdmitted, duplicate,
                 sourceKind, failureSource: sourceObservation.failureSource ?? null, triggerOutcome: trigger.outcome,
                 triggerReason: trigger.reason, painScore, isRisky, relativePath, agentId: enrichment.agentId ?? null,
                 evidence: enrichment.evidence ?? [],

package/host-runtime/dist/prompt-activation-deliverability.js

@@ -3,7 +3,7 @@ import path from 'node:path';
 import { RUNTIME_V2_PRINCIPLE_BUDGET, SqliteConnection, SqlitePIArtifactStore, computeFeatureFlagsFromConfig, listEntryLine, renderPrinciplesToDirectives, resolvePrincipleFromArtifact, trimToBudget, } from '@principles/core/runtime-v2';
 import { escapeXml } from '@principles/core/prompt-builder';
 import { loadPdConfigForPlugin } from './pd-config.js';
-import { PROMPT_INJECTION_UNIT, promptRouteForHost, resolvePromptInjectionRouteDecision, } from './prompt-injection-projection.js';
+import { PROMPT_INJECTION_TARGET_HOSTS, PROMPT_INJECTION_UNIT, promptRouteForHost, resolvePromptInjectionRouteDecision, } from './prompt-injection-projection.js';
 function syntheticPendingActivation(artifactId) {
     return {
         activationId: `pending:${artifactId}`,
@@ -114,8 +114,9 @@ export async function checkPromptArtifactDeliverability(input) {
     }
     // Route unconfirmed: report per-host fit for every standard host instead of
     // guessing (R-A1) — the write gate refuses, the UI can show both facts.
-    const hosts = ['openclaw', 'codex'];
-    const perHost = hosts.map((hostKind) => {
+    // Roster derives from the single SSoT list (review P3-1: a hand-typed
+    // two-host array dropped WorkBuddy from unconfirmed deliverability reports).
+    const perHost = PROMPT_INJECTION_TARGET_HOSTS.map((hostKind) => {
         const route = promptRouteForHost(hostKind, decision.flagEnabled);
         const { fits, costChars } = computePromptSingleItemFit({
             principle: resolved.principle,
@@ -127,7 +128,7 @@ export async function checkPromptArtifactDeliverability(input) {
     return {
         status: 'unconfirmed',
         reason: `route_unconfirmed: ${decision.unconfirmedReason ?? 'effective injection route cannot be confirmed'}`,
-        nextAction: decision.nextAction ?? 'pass an explicit target host (openclaw|codex)',
+        nextAction: decision.nextAction ?? 'pass an explicit target host (openclaw|codex|workbuddy)',
         perHost,
     };
 }

package/host-runtime/dist/prompt-injection-event-evidence.d.ts

@@ -25,7 +25,7 @@
 export interface InjectionEvidenceRow {
     workspaceDir: string;
     activationId: string;
-    hostKind: 'openclaw' | 'codex' | 'unknown';
+    hostKind: 'openclaw' | 'codex' | 'workbuddy' | 'unknown';
     hostIdentityComplete: boolean;
     eventIdentityComplete: boolean;
     /** Deduplicated injection facts: this activation appeared in the injected set. */

package/host-runtime/dist/prompt-injection-event-evidence.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { isPromptInjectionTargetHost } from './prompt-injection-projection.js';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -63,7 +64,10 @@ export function readInjectionEventEvidence(input) {
             const runId = nonEmptyString(data.runId);
             const eventId = nonEmptyString(data.eventId);
             const rawHostKind = data.hostKind;
-            const hostKind = rawHostKind === 'openclaw' || rawHostKind === 'codex' ? rawHostKind : 'unknown';
+            // Known-host membership comes from the roster predicate (review R1: the
+            // hand-typed openclaw|codex check classified real WorkBuddy injection
+            // events as the unknown bucket, contradicting this row's own type).
+            const hostKind = isPromptInjectionTargetHost(rawHostKind) ? rawHostKind : 'unknown';
             const { activationIds } = data;
             if (workspaceDir === undefined || sessionId === undefined || !Array.isArray(activationIds)
                 || !activationIds.every((id) => typeof id === 'string')) {

package/host-runtime/dist/prompt-injection-projection.d.ts

@@ -1,7 +1,14 @@
 import { type PromptSelectionPolicy } from '@principles/core/runtime-v2';
 /** Hosts with a production prompt-injection path today (shared GovernanceHostKind boundary). */
-export type PromptInjectionTargetHost = 'openclaw' | 'codex';
+export type PromptInjectionTargetHost = 'openclaw' | 'codex' | 'workbuddy';
+/** Single host roster (review P2): every consumer derives from this list, so a
+ * new host cannot fork route-unconfirmed per-host forecasts from the routes. */
 export declare const PROMPT_INJECTION_TARGET_HOSTS: readonly PromptInjectionTargetHost[];
+/** Runtime membership test derived from the roster (rc-2): the ONE guard for
+ * "is this untrusted host-kind string a host with a known prompt-injection
+ * route". Every consumer narrows with this — never by re-typing the literals
+ * (review R1: each re-typed list forked the roster and dropped WorkBuddy). */
+export declare function isPromptInjectionTargetHost(kind: unknown): kind is PromptInjectionTargetHost;
 export type PromptInjectionRouteName = 'legacy_trim' | 'shared_render';
 /**
  * Which serialization the budget is charged against (SPEC R-A2): the legacy
@@ -48,9 +55,11 @@ export interface PromptInjectionRouteDecision {
 }
 /**
  * THE one route formula (P4): Codex always injects through the shared route
- * (codex-adapter has no flag branch); OpenClaw routes by its
- * `abstraction_layer_v1` gate. Every consumer that needs "which route would
- * host X take" must call this — never re-type the ternary.
+ * (codex-adapter has no flag branch); so does WorkBuddy (workbuddy-adapter
+ * renders through the shared runtime unconditionally — it has no legacy
+ * route); OpenClaw routes by its `abstraction_layer_v1` gate. Every consumer
+ * that needs "which route would host X take" must call this — never re-type
+ * the ternary.
  */
 export declare function promptRouteForHost(hostKind: PromptInjectionTargetHost, flagEnabled: boolean): PromptInjectionRouteName;
 /**
@@ -175,7 +184,7 @@ export declare function buildLivePromptInjectionProjection(input: {
      * rather than assuming FIFO.
      */
     roundKey?: number;
-    /** AC-01: explicit route binding — 'codex' always shared, 'openclaw' by flag. */
+    /** AC-01: explicit route binding — 'codex'/'workbuddy' always shared, 'openclaw' by flag. */
     targetHost?: PromptInjectionTargetHost;
 }): Promise<PromptInjectionProjection>;
 /**