create-principles-disciple 1.144.26 → 1.145.0

package/_release/product-identity.json

@@ -1,5 +1,5 @@
 {
   "schemaVersion": 1,
-  "productVersion": "2.3.1",
-  "sourceCommit": "ce1ba2ca021468f7ceb78d9416ca9e9d1d08c9f0"
+  "productVersion": "2.3.3",
+  "sourceCommit": "05b982eeb4b18d6cf3bc438333c462aa027af505"
 }

package/codex-adapter/dist/codex-evidence-recorder.js

@@ -112,7 +112,11 @@ export function recordCodexPromptDeliveryEvidence(input) {
                 principleId: entry.principleId,
                 ...(activationRef.artifactId ? { artifactId: activationRef.artifactId } : {}),
                 ...(contentRef ? { payloadDigest: contentRef.payloadDigest } : {}),
-                resolution: contentRef ? 'resolved' : 'revision_reference_unresolved',
+                // A stored contentRef is an OBJECT — its truthiness must not upgrade
+                // resolution: 'resolved' without a payloadDigest is rejected by the
+                // normalizer before the store's idempotent dedup branch can no-op the
+                // replay. Only a digest-carrying reference counts as resolved.
+                resolution: contentRef?.payloadDigest !== undefined ? 'resolved' : 'revision_reference_unresolved',
             },
             activationRef,
             payload: { targetKind: 'agent_context', confirmation: 'submitted', outcome: 'attempted' },
@@ -162,7 +166,9 @@ export function recordCodexDenyEvidence(input) {
         principleId: input.principleId,
         ...(activationRef.artifactId ? { artifactId: activationRef.artifactId } : {}),
         ...(content ? { payloadDigest: content.payloadDigest } : {}),
-        resolution: content ? 'resolved' : 'revision_reference_unresolved',
+        // Same constraint as the prompt-delivery path above: a stored object's
+        // truthiness must not mint a digest-less 'resolved' reference.
+        resolution: content?.payloadDigest !== undefined ? 'resolved' : 'revision_reference_unresolved',
     };
     const observations = [
         {

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

@@ -21,5 +21,5 @@ export { catchUpCodexIngestion, CODEX_CATCH_UP_NEXT_ACTION } from './ingestion/c
 export type { CodexCatchUpOptions, CodexCatchUpResult, CodexCatchUpRolloutResult } from './ingestion/catch-up.js';
 export { locateCodexTranscriptByRolloutIdentity } from './ingestion/transcript-locate.js';
 export type { CodexTranscriptLookup } from './ingestion/transcript-locate.js';
-export { runCodexWorkspaceWorkerCycle, computeCodexWorkerStatusMode } from './worker/workspace-worker.js';
-export type { CodexWorkerMode, CodexWorkerCycleResult, CodexWorkerCycleStepReport, CodexWorkerCycleOptions, CodexWorkerStatusEvaluation } from './worker/workspace-worker.js';
+export { runCodexWorkspaceWorkerCycle, computeCodexWorkerStatusMode, readCodexWorkerLiveness } from './worker/workspace-worker.js';
+export type { CodexWorkerMode, CodexWorkerCycleResult, CodexWorkerCycleStepReport, CodexWorkerCycleOptions, CodexWorkerStatusEvaluation, CodexWorkerPostProcessingReport } from './worker/workspace-worker.js';

package/codex-adapter/dist/index.js

@@ -16,4 +16,4 @@ export { decodeTranscriptWindow, createNodeTranscriptPort, TranscriptReplacedErr
 // PRI-624 Slice C: bounded catch-up + per-workspace worker cycle.
 export { catchUpCodexIngestion, CODEX_CATCH_UP_NEXT_ACTION } from './ingestion/catch-up.js';
 export { locateCodexTranscriptByRolloutIdentity } from './ingestion/transcript-locate.js';
-export { runCodexWorkspaceWorkerCycle, computeCodexWorkerStatusMode } from './worker/workspace-worker.js';
+export { runCodexWorkspaceWorkerCycle, computeCodexWorkerStatusMode, readCodexWorkerLiveness } from './worker/workspace-worker.js';

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

@@ -47,6 +47,15 @@ export function buildLiveToolCandidate(args) {
         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,
         ...(fields.toolInput !== undefined ? { toolInput: fields.toolInput } : {}),
         ...(fields.toolResponse !== undefined ? { toolOutput: fields.toolResponse } : {}),
         observedAt: new Date().toISOString(),
@@ -90,6 +99,13 @@ export function buildTranscriptCandidates(observations) {
                 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,

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

@@ -3,9 +3,15 @@
  * Slice A; ADR-0020 §11.2 + G1 probe report §9).
  *
  * The G1 contract baseline is: minimum supported Codex 0.148.0, verified
- * on-device at 0.150.1. The transcript itself carries `session_meta.
- * payload.cli_version`, which is the version signal available inside a hook
- * subprocess (hook payloads carry no version field — G1 fixture contract).
+ * on-device at 0.150.1 and re-verified at 0.162.1 (PRI-953, 2026-10-13:
+ * on-device probe against real codex-cli 0.162.1 — 125/125 captured hook
+ * payloads decode, 8/8 real rollout transcripts ingest with only designed
+ * unknown-record-type skips; sanitized fixtures:
+ * tests/fixtures/g1-contract/hook-payloads/v0.162.1/ and
+ * transcripts/v0.162.1-tool-final-turn.jsonl). The transcript itself carries
+ * `session_meta.payload.cli_version`, which is the version signal available
+ * inside a hook subprocess (hook payloads carry no version field — G1
+ * fixture contract).
  *
  * Older-than-minimum and newer-than-verified versions both degrade
  * explicitly; an unknown version must never silently guess record fields.
@@ -13,7 +19,7 @@
  * refreshing the fixtures (G1 report §9 drift-detection boundary).
  */
 export declare const CODEX_INGESTION_MIN_VERSION = "0.148.0";
-export declare const CODEX_INGESTION_VERIFIED_VERSION = "0.150.1";
+export declare const CODEX_INGESTION_VERIFIED_VERSION = "0.162.1";
 export type CodexVersionClassification = {
     status: 'supported';
 } | {

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

@@ -3,9 +3,15 @@
  * Slice A; ADR-0020 §11.2 + G1 probe report §9).
  *
  * The G1 contract baseline is: minimum supported Codex 0.148.0, verified
- * on-device at 0.150.1. The transcript itself carries `session_meta.
- * payload.cli_version`, which is the version signal available inside a hook
- * subprocess (hook payloads carry no version field — G1 fixture contract).
+ * on-device at 0.150.1 and re-verified at 0.162.1 (PRI-953, 2026-10-13:
+ * on-device probe against real codex-cli 0.162.1 — 125/125 captured hook
+ * payloads decode, 8/8 real rollout transcripts ingest with only designed
+ * unknown-record-type skips; sanitized fixtures:
+ * tests/fixtures/g1-contract/hook-payloads/v0.162.1/ and
+ * transcripts/v0.162.1-tool-final-turn.jsonl). The transcript itself carries
+ * `session_meta.payload.cli_version`, which is the version signal available
+ * inside a hook subprocess (hook payloads carry no version field — G1
+ * fixture contract).
  *
  * Older-than-minimum and newer-than-verified versions both degrade
  * explicitly; an unknown version must never silently guess record fields.
@@ -13,7 +19,7 @@
  * refreshing the fixtures (G1 report §9 drift-detection boundary).
  */
 export const CODEX_INGESTION_MIN_VERSION = '0.148.0';
-export const CODEX_INGESTION_VERIFIED_VERSION = '0.150.1';
+export const CODEX_INGESTION_VERIFIED_VERSION = '0.162.1';
 export const CODEX_VERSION_NEXT_ACTION = 'rerun the Codex contract probe / update supported fixtures (docs/architecture/CODEX_G1_CONTRACT_PROBE_REPORT.md §9)';
 function isDigits(value) {
     return value.length > 0 && /^[0-9]+$/.test(value);

package/codex-adapter/dist/ingestion/explicit-owner-statement.d.ts

@@ -0,0 +1,48 @@
+/** The exact prefix (fullwidth colon) defined by SPEC §6.4. */
+export declare const CODEX_OWNER_STATEMENT_PREFIX = "PD\u8BB0\u5F55\u75DB\u82E6\uFF1A";
+/** SPEC §6.1: reject instead of truncating the Owner's intent. */
+export declare const MAX_OWNER_STATEMENT_CHARS = 500;
+export type OwnerStatementPrefixParse = {
+    matched: false;
+} | {
+    matched: true;
+    text: string | null;
+    reason?: 'statement_empty' | 'statement_too_long';
+};
+/**
+ * Deterministic prefix parse of the CURRENT user prompt. `text === null` means
+ * the prefix matched but the remainder was empty/blank — an explicit request
+ * with no content is a bounded rejection, never a fabricated statement.
+ */
+export declare function parseOwnerStatementPrefix(prompt: unknown): OwnerStatementPrefixParse;
+export type RecordOwnerStatementResult = {
+    status: 'received';
+    painId: string;
+    taskId: string;
+    disposition: 'admitted' | 'already_admitted';
+    logicalObservationKey: string;
+    /**
+     * SPEC §6.4.5: the durable task is what the receipt guarantees; evidence
+     * promotion may degrade (e.g. conversation ingestion off — no ingested
+     * rollout to promote from). The receipt discloses it instead of failing.
+     */
+    promotionDegraded?: string;
+} | {
+    status: 'rejected';
+    reason: 'statement_empty' | 'statement_too_long' | 'transcript_unavailable' | 'lineage_invalid' | 'rate_limited' | 'continuation_failed';
+    nextAction: string;
+};
+/**
+ * Persist one explicit Owner statement. The consent-gated conversation
+ * ingestion flag does NOT gate this path (no conversation tables or transcript
+ * CONTENT are read — only the path is validated for the rollout identity),
+ * mirroring SPEC §6.4 rule 3.
+ */
+export declare function recordExplicitOwnerStatement(args: {
+    rawPayload: unknown;
+    workspaceDir: string;
+    statementText: string;
+    env?: {
+        CODEX_HOME?: string | undefined;
+    };
+}): Promise<RecordOwnerStatementResult>;

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

@@ -0,0 +1,123 @@
+/**
+ * SPEC-CODEX-PAIN-CLOSURE-001 CR-07 — the explicit Owner pain-report entry
+ * for Codex: the user types `PD记录痛苦：<反馈原文>` as the CURRENT message
+ * and this deterministic prefix parse turns exactly that text into one
+ * canonical pain signal through the existing governance admission +
+ * diagnostician-task continuation seams.
+ *
+ * Contract (SPEC §6.4):
+ *   - ONLY an exact prefix match at the start of the CURRENT user prompt
+ *     counts. Quoted text, tool output, model prose and ordinary corrections
+ *     never trigger it (A17).
+ *   - The statement is bounded at 500 chars (rejection, not truncation).
+ *   - Identity comes from THIS hook payload's verified session/turn ids plus
+ *     the transcript-path-derived rollout identity — the model never guesses
+ *     ids and no other file is scanned.
+ *   - The same logical observation key as the generic correction path
+ *     (`codex|<rollout>|<turn>|user`) means explicit and generic detection of
+ *     one turn converge on ONE canonical pain (unique marker dedup).
+ *   - No LLM runs here: admission + durable enqueue only, well inside the
+ *     5s hook budget; the receipt carries painId/taskId.
+ */
+import { admitGovernanceSignals, ensureGovernanceDiagnosticianTask, promoteAdmittedGovernanceEvidence, } from '@principles/host-runtime';
+import { resolveCodexHome } from './codex-home.js';
+import { validateCodexTranscriptPath } from './transcript-path.js';
+import { extractFields } from './ingestion-fields.js';
+/** The exact prefix (fullwidth colon) defined by SPEC §6.4. */
+export const CODEX_OWNER_STATEMENT_PREFIX = 'PD记录痛苦：';
+/** SPEC §6.1: reject instead of truncating the Owner's intent. */
+export const MAX_OWNER_STATEMENT_CHARS = 500;
+/**
+ * Deterministic prefix parse of the CURRENT user prompt. `text === null` means
+ * the prefix matched but the remainder was empty/blank — an explicit request
+ * with no content is a bounded rejection, never a fabricated statement.
+ */
+export function parseOwnerStatementPrefix(prompt) {
+    if (typeof prompt !== 'string')
+        return { matched: false };
+    if (!prompt.startsWith(CODEX_OWNER_STATEMENT_PREFIX))
+        return { matched: false };
+    const remainder = prompt.slice(CODEX_OWNER_STATEMENT_PREFIX.length).trim();
+    if (remainder.length === 0)
+        return { matched: true, text: null, reason: 'statement_empty' };
+    if (remainder.length > MAX_OWNER_STATEMENT_CHARS)
+        return { matched: true, text: null, reason: 'statement_too_long' };
+    return { matched: true, text: remainder };
+}
+/**
+ * Persist one explicit Owner statement. The consent-gated conversation
+ * ingestion flag does NOT gate this path (no conversation tables or transcript
+ * CONTENT are read — only the path is validated for the rollout identity),
+ * mirroring SPEC §6.4 rule 3.
+ */
+export async function recordExplicitOwnerStatement(args) {
+    const fields = extractFields(args.rawPayload);
+    if (fields === null || fields.sessionId.length === 0 || fields.turnId === null) {
+        return { status: 'rejected', reason: 'lineage_invalid', nextAction: 'The hook payload lacks the session/turn identity this explicit submission requires; nothing was recorded.' };
+    }
+    if (fields.transcriptPath === null) {
+        return { status: 'rejected', reason: 'transcript_unavailable', nextAction: 'Codex supplied no transcript path for this event; the explicit statement was NOT recorded — resubmit it in a new message.' };
+    }
+    const home = resolveCodexHome(args.env);
+    if (!home.ok) {
+        return { status: 'rejected', reason: 'transcript_unavailable', nextAction: `${home.reason}: ${home.nextAction}`.slice(0, 400) };
+    }
+    const validated = validateCodexTranscriptPath(fields.transcriptPath, home.home);
+    if (!validated.ok) {
+        return { status: 'rejected', reason: 'lineage_invalid', nextAction: `${validated.reason}: ${validated.nextAction}`.slice(0, 400) };
+    }
+    const candidate = {
+        kind: 'user_correction',
+        hostKind: 'codex',
+        logicalObservationKey: `codex|${validated.rolloutIdentity}|${fields.turnId}|user`,
+        rolloutIdentity: validated.rolloutIdentity,
+        rootSessionId: fields.sessionId,
+        hostTurnId: fields.turnId,
+        text: args.statementText,
+        observedAt: new Date().toISOString(),
+        explicitOwnerStatement: true,
+    };
+    const admitted = admitGovernanceSignals({ workspaceDir: args.workspaceDir, candidates: [candidate] });
+    if (!admitted.ok) {
+        return { status: 'rejected', reason: 'continuation_failed', nextAction: `${admitted.reason}: ${admitted.nextAction}`.slice(0, 400) };
+    }
+    const [outcome] = admitted.outcomes;
+    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') {
+        return { status: 'rejected', reason: 'continuation_failed', nextAction: 'reason' in outcome ? String(outcome.reason) : 'the signal was not admitted' };
+    }
+    if (outcome.disposition === 'rate_limited') {
+        return { status: 'rejected', reason: 'rate_limited', nextAction: 'The per-root-session correction quota (5/hour) is exhausted; resubmit later — the statement was NOT recorded.' };
+    }
+    // Task ensure is the receipt's hard guarantee; evidence promotion is
+    // best-effort (SPEC §6.4.5 — a degraded promotion is disclosed, never a
+    // failed receipt: the pain + task are durably recorded).
+    const ensured = await ensureGovernanceDiagnosticianTask({
+        workspaceDir: args.workspaceDir,
+        logicalObservationKey: candidate.logicalObservationKey,
+        canonicalPainId: outcome.canonicalPainId,
+    });
+    if (!ensured.ok) {
+        return { status: 'rejected', reason: 'continuation_failed', nextAction: `${ensured.reason}: ${ensured.nextAction}`.slice(0, 400) };
+    }
+    let promotionDegraded;
+    const promoted = promoteAdmittedGovernanceEvidence({
+        workspaceDir: args.workspaceDir,
+        rolloutIdentity: validated.rolloutIdentity,
+        triggerLogicalKey: candidate.logicalObservationKey,
+        canonicalPainId: outcome.canonicalPainId,
+    });
+    if (!promoted.ok) {
+        promotionDegraded = `${promoted.reason}`.slice(0, 160);
+    }
+    return {
+        status: 'received',
+        painId: outcome.canonicalPainId,
+        taskId: ensured.taskId,
+        disposition: outcome.disposition === 'already_admitted' ? 'already_admitted' : 'admitted',
+        logicalObservationKey: candidate.logicalObservationKey,
+        ...(promotionDegraded !== undefined ? { promotionDegraded } : {}),
+    };
+}

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

@@ -1,4 +1,4 @@
-import { ingestGovernanceObservations, readGovernanceCheckpoint, } from '@principles/host-runtime';
+import { ingestGovernanceObservations, readGovernanceCheckpoint, recordVerifiedToolOutcomes, } from '@principles/host-runtime';
 import { resolveCodexHome } from './codex-home.js';
 import { validateCodexTranscriptPath } from './transcript-path.js';
 import { classifyCodexVersion, CODEX_VERSION_NEXT_ACTION } from './codex-version.js';
@@ -70,6 +70,43 @@ function ingestLiveObservation({ fields, rolloutIdentity, workspaceDir, now }) {
         rolloutIdentity,
     };
 }
+/**
+ * SPEC-CODEX-PAIN-CLOSURE-001 CR-01: project decoded CommandExecution facts
+ * onto the shared verified-outcome upgrade. The transcript's model-level call
+ * name for the shell tool is `exec` while the PostToolUse hook names it
+ * `Bash` (g1 fixture 04-post-tool-use.json ↔ normal-tool-final-turn.jsonl,
+ * same tool_use_id) — the host-specific mapping stays here in the adapter.
+ */
+function collectVerifiedToolOutcomes(observations) {
+    const outcomes = [];
+    for (const observation of observations) {
+        if (observation.kind !== 'tool_call' || observation.toolUseId === undefined)
+            continue;
+        const facts = observation.toolFacts;
+        if (typeof facts !== 'object' || facts === null || Array.isArray(facts))
+            continue;
+        const { exitCode } = facts;
+        if (typeof exitCode !== 'number' || !Number.isInteger(exitCode))
+            continue;
+        const rawName = facts.toolName;
+        const toolName = rawName === 'exec' || typeof rawName !== 'string' || rawName.length === 0 ? 'Bash' : rawName;
+        const { stdout } = facts;
+        const { stderr } = facts;
+        const previewParts = [];
+        if (typeof stderr === 'string' && stderr.length > 0)
+            previewParts.push(stderr);
+        if (typeof stdout === 'string' && stdout.length > 0)
+            previewParts.push(stdout);
+        outcomes.push({
+            toolUseId: observation.toolUseId,
+            toolName,
+            params: facts.command ?? undefined,
+            exitCode,
+            ...(previewParts.length > 0 ? { outputPreview: previewParts.join('\n') } : {}),
+        });
+    }
+    return outcomes;
+}
 function ingestTranscriptDelta({ fallbackRootSessionId, canonicalPath, identity, rolloutIdentity, workspaceDir, now, port }) {
     const checkpoint = readGovernanceCheckpoint({ workspaceDir, hostKind: 'codex', rolloutIdentity });
     if (checkpoint !== null && !('byteOffset' in checkpoint) && 'ok' in checkpoint && checkpoint.ok === false) {
@@ -126,6 +163,18 @@ function ingestTranscriptDelta({ fallbackRootSessionId, canonicalPath, identity,
         degradations.push({ reason: 'transcript_record_too_large', nextAction: 'a single transcript record exceeds the bounded-read window; inspect the rollout file.' });
     }
     const rootSessionId = decoded.rolloutMeta.rootSessionId ?? existing?.rootSessionId ?? fallbackRootSessionId;
+    // CR-01: upgrade text-only live observations with the host-verified exit
+    // codes BEFORE the checkpoint advances, so a write failure holds the delta
+    // and the next Stop retries instead of silently losing the verified facts.
+    const verifiedOutcomes = collectVerifiedToolOutcomes(decoded.observations);
+    if (verifiedOutcomes.length > 0) {
+        const verified = recordVerifiedToolOutcomes({ workspaceDir, sessionId: rootSessionId, outcomes: verifiedOutcomes });
+        const failed = verified.find((result) => result.status === 'unavailable');
+        if (failed !== undefined) {
+            const reason = failed.reason === 'trajectory_db_not_found' ? 'verified_outcome_db_unavailable' : `verified_outcome_write_failed:${failed.reason.split(':', 2)[1] ?? ''}`;
+            return { status: 'degraded', reason, nextAction: 'inspect the workspace trajectory database; the transcript checkpoint was NOT advanced, the next Stop retries this delta.', warnings: decoded.warnings };
+        }
+    }
     const result = ingestGovernanceObservations({
         workspaceDir,
         rollout: {

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

@@ -12,6 +12,7 @@ import { CodexHooksHostAdapter } from './host-adapter.js';
 import { CodexDecoderError, CodexEncoderError } from './codec/index.js';
 import { ingestCodexConversation } from './ingestion/ingestion.js';
 import { runGovernanceAdmission } from './ingestion/admission.js';
+import { parseOwnerStatementPrefix, recordExplicitOwnerStatement } from './ingestion/explicit-owner-statement.js';
 import { recordCodexPromptDeliveryEvidence, recordCodexDenyEvidence } from './codex-evidence-recorder.js';
 const MAX_DIAGNOSTIC = 500;
 function diagnostic(reason, nextAction) {
@@ -190,9 +191,15 @@ async function runConversationIngestion(args) {
             // Slice B admission: hook awaits only admission + durable enqueue —
             // never an LLM (SPEC §12/§13). Ordinary conversation returns no
             // candidates/no admissions and stays completely silent.
+            // CR-07: when the explicit Owner-statement entry already handled this
+            // turn's prompt, its generic correction candidate is suppressed so the
+            // observation passes through exactly one pain writer.
+            const candidates = args.suppressCorrectionCandidate === true
+                ? outcome.admissionCandidates.filter((candidate) => candidate.kind !== 'user_correction')
+                : outcome.admissionCandidates;
             const admission = await runGovernanceAdmission({
                 workspaceDir,
-                candidates: outcome.admissionCandidates,
+                candidates,
             });
             for (const degradation of admission.degradations.slice(0, 2)) {
                 diagnostics.push(diagnostic(degradation.reason, degradation.nextAction));
@@ -276,8 +283,53 @@ export async function processHookInvocation(rawStdin, _env = process.env, cwd =
                 return { stdout: {}, exitCode: 0, stderr: [diagnostic(health.reason ?? 'runtime_unhealthy', health.nextAction ?? 'Inspect the Workspace runtime.')] };
             return { stdout: adapter.encodeOutput({ decision: 'allow', source: event.source }, 'session_start'), exitCode: 0, stderr: [] };
         }
+        // SPEC-CODEX-PAIN-CLOSURE-001 CR-07: the explicit Owner statement entry
+        // runs FIRST for the current user prompt — before the generic correction
+        // detection, so the same turn can never pass through two pain writers
+        // (the shared unique observation key dedups any replay). Works regardless
+        // of the codex_conversation_ingestion flag: only the transcript PATH is
+        // validated (rollout identity), never conversation content.
+        let explicitReceiptContext;
+        let explicitSuppressedGeneric = false;
+        const explicitDiagnostics = [];
+        if (event.kind === 'before_prompt_build') {
+            const rawRecord = parsed;
+            const prefixParse = parseOwnerStatementPrefix(typeof rawRecord?.prompt === 'string' ? rawRecord.prompt : undefined);
+            if (prefixParse.matched) {
+                explicitSuppressedGeneric = true;
+                if (prefixParse.text === null) {
+                    explicitDiagnostics.push(diagnostic(`owner_statement_${prefixParse.reason ?? 'rejected'}`, prefixParse.reason === 'statement_too_long'
+                        ? `The statement exceeds 500 characters; nothing was recorded. Resubmit within the limit.`
+                        : 'The prefix carried no statement text; nothing was recorded. Resubmit as PD记录痛苦：<反馈原文>.'));
+                }
+                else {
+                    const receipt = await recordExplicitOwnerStatement({
+                        rawPayload: parsed,
+                        workspaceDir: resolution.workspaceDir,
+                        statementText: prefixParse.text,
+                        env: _env,
+                    });
+                    if (receipt.status === 'received') {
+                        explicitReceiptContext = `[PD] 已收到痛苦反馈（painId=${receipt.painId}, taskId=${receipt.taskId}${receipt.disposition === 'already_admitted' ? ', 重复提交已合并为同一信号' : ''}）。后台将自动诊断；请在回复中如实转述本回执，不要声称仍在等待用户输入，也不要虚构诊断结论。${receipt.promotionDegraded !== undefined ? `（注意：会话证据提升暂不可用：${receipt.promotionDegraded}；诊断仍会基于你提交的陈述进行。）` : ''}`;
+                        explicitDiagnostics.push(diagnostic(`owner_statement_received:${receipt.painId}:${receipt.taskId}${receipt.promotionDegraded !== undefined ? `:promotion_degraded:${receipt.promotionDegraded}` : ''}`, 'Durable enqueue complete; the workspace worker continues diagnosis in the background.'));
+                    }
+                    else {
+                        explicitDiagnostics.push(diagnostic(`owner_statement_${receipt.reason}`, receipt.nextAction));
+                    }
+                }
+            }
+        }
         const ingestionDiagnostics = ingestionEnabled
-            ? await runConversationIngestion({ rawPayload: parsed, kind: event.kind, workspaceDir: resolution.workspaceDir, env: _env })
+            ? await runConversationIngestion({
+                rawPayload: parsed,
+                kind: event.kind,
+                workspaceDir: resolution.workspaceDir,
+                env: _env,
+                // CR-07: the explicit path already handled this turn's user prompt —
+                // suppress the generic correction candidate so exactly one writer
+                // processed the observation (A17).
+                ...(explicitSuppressedGeneric && event.kind === 'before_prompt_build' ? { suppressCorrectionCandidate: true } : {}),
+            })
             : [];
         // PD v2 Phase 1: evidence context for this subprocess invocation. The
         // ledger flag follows the OpenClaw convention (principle_receipt_ledger
@@ -314,6 +366,17 @@ export async function processHookInvocation(rawStdin, _env = process.env, cwd =
         // v2 enforcement is suspended (PRI-780); wired honestly for the day it
         // is not.
         const encoded = adapter.encodeOutput(result, event.kind);
+        // CR-07 (A16): the explicit-statement receipt rides as additional context
+        // so the model can answer truthfully about what happened (received +
+        // queued), instead of guessing or claiming it is still waiting for input.
+        if (explicitReceiptContext !== undefined && event.kind === 'before_prompt_build') {
+            const output = encoded;
+            if (output.hookSpecificOutput !== undefined) {
+                output.hookSpecificOutput.additionalContext = output.hookSpecificOutput.additionalContext !== undefined
+                    ? `${output.hookSpecificOutput.additionalContext}\n${explicitReceiptContext}`
+                    : explicitReceiptContext;
+            }
+        }
         if (result.decision === 'deny') {
             try {
                 let liveActivationId;
@@ -356,7 +419,7 @@ export async function processHookInvocation(rawStdin, _env = process.env, cwd =
                 evidenceDiagnostics.push(diagnostic(`codex_evidence_deny_failed:${errorMessage(error)}`, 'The deny decision was already encoded; evidence replay from the durable source is safe.'));
             }
         }
-        const stderr = [...annotateContextWarnings(result.warnings ?? []).slice(0, 16).map((warning) => diagnostic(warning, 'Inspect PD Workspace state and retry; the hook failed open.')), ...evaluationDiagnostics, ...evidenceDiagnostics, ...ingestionDiagnostics];
+        const stderr = [...annotateContextWarnings(result.warnings ?? []).slice(0, 16).map((warning) => diagnostic(warning, 'Inspect PD Workspace state and retry; the hook failed open.')), ...evaluationDiagnostics, ...evidenceDiagnostics, ...explicitDiagnostics, ...ingestionDiagnostics];
         return { stdout: encoded, exitCode: 0, stderr };
     }
     catch (error) {

package/codex-adapter/dist/worker/workspace-worker.d.ts

@@ -2,9 +2,22 @@ import { type InternalizationConsumerCycleOutcome, type ConsumerCycleLogger, typ
 import { type CodexCatchUpResult } from '../ingestion/catch-up.js';
 import type { TranscriptPort } from '../ingestion/transcript-decoder.js';
 export type CodexWorkerMode = 'ready' | 'manual_action_required' | 'paused' | 'degraded';
+export interface CodexWorkerPostProcessingReport {
+    readonly resumedTaskIds: readonly string[];
+    readonly processedCount: number;
+    /** Eligible-after-this-cycle backlog size (oldest-first scan is bounded). */
+    readonly remainingCount: number;
+    readonly oldestAgeMs: number | null;
+    readonly blocked: readonly {
+        candidateId: string;
+        reason: string;
+    }[];
+}
 export interface CodexWorkerCycleStepReport {
     readonly catchUp: CodexCatchUpResult;
     readonly reconcile: ReconcileGovernanceContinuationResult;
+    /** CR-05: succeeded-diagnosis post-processing continuation (no LLM). */
+    readonly postProcessing: CodexWorkerPostProcessingReport | null;
     /** At most ONE diagnostician execution per cycle (bounded work). */
     readonly diagnostician: {
         readonly taskId: string;
@@ -41,6 +54,7 @@ export interface CodexWorkerCycleOptions {
     /** Cap on diagnostician candidates inspected per cycle (default 5). */
     readonly diagnosticianCandidateLimit?: number;
 }
+export declare function readCodexWorkerLiveness(workspaceDir: string): Record<string, unknown> | null;
 /**
  * Run ONE bounded worker cycle for a canonical workspace. Never throws:
  * every failure becomes a structured degraded result with a nextAction.