create-principles-disciple 1.145.1 → 1.145.4

package/host-runtime/dist/behavior-example-pack-assembler.d.ts

@@ -0,0 +1,41 @@
+import type { BehaviorExamplePack } from '@principles/core/runtime-v2';
+import type { RuleHostEvidenceRow, RuleHostContextRow } from '@principles/core/trajectory-types';
+import type { ToolSemanticRegistry } from '@principles/core/runtime-v2';
+export interface BehaviorExampleDataSource {
+    getPainEventByCanonicalId(id: string): {
+        id: number;
+        sessionId: string;
+    } | null;
+    getRuleHostEvidenceRow(id: number): RuleHostEvidenceRow | null;
+    getRuleHostContextRowsBefore(sessionId: string, beforeId: number, limit: number): {
+        rows: readonly RuleHostContextRow[];
+        truncated: boolean;
+    };
+}
+export interface BehaviorExamplePackAssemblerOptions {
+    readonly source: BehaviorExampleDataSource;
+    readonly toolSemantics: ToolSemanticRegistry;
+}
+export interface BehaviorExamplePackAssemblerInput {
+    /** Canonical pain ID (e.g. pain_<ts>_<hash>) — entry point into pain lineage. */
+    readonly sourcePainId: string;
+    /** Owner's natural-language desired outcome — must be non-empty. */
+    readonly ownerDesiredOutcome: string;
+    /** Owner-selected call that demonstrates behaviour to block. */
+    readonly sourceNegativeToolCallId: number;
+    /** Owner-selected calls that demonstrate behaviour to allow (1..3). */
+    readonly positiveToolCallIds: readonly number[];
+    /**
+     * Project directory, used to detect absolute paths that should be redacted
+     * to relative/basename form in the assembled pack.
+     */
+    readonly projectDir: string;
+}
+export declare class BehaviorExamplePackAssembler {
+    private readonly db;
+    private readonly toolSemantics;
+    constructor(opts: BehaviorExamplePackAssemblerOptions);
+    /** Assemble only from explicit Owner labels; execution outcome is not a label. */
+    assemble(input: BehaviorExamplePackAssemblerInput): BehaviorExamplePack;
+    private buildSelectedCase;
+}

package/host-runtime/dist/behavior-example-pack-assembler.js

@@ -0,0 +1,243 @@
+/**
+ * Shared Owner-labelled BehaviorExamplePack assembly (PRI-484 / PRI-992).
+ *
+ * Reads pain lineage + trajectory rows from TrajectoryDatabase and assembles
+ * a validated BehaviorExamplePack for the Artificer. Fail loud on any gap
+ * (missing pain, empty trajectory, invalid pack) — no silent fallback.
+ *
+ * Err-prevention:
+ *   - ERR-001: every DB row field validated as `unknown` (no `as` bypass on
+ *     parsed params_json or row casts).
+ *   - ERR-069: Artificer shared schema — invalid pack must fail loud.
+ *   - ERR-026: reuses production TrajectoryDatabase (no hand-written DDL).
+ *   - rc-2: structural type guards, no `as T` on parsed input.
+ *   - rc-5: Object.hasOwn over `in`.
+ *   - rc-9: every failure path throws a structured Error with a clear reason.
+ *   - PRI-980 review P2-1: trajectory STORE I/O failures throw the typed
+ *     `evidence_source_error` (readTrajectoryStore) so the readiness contract
+ *     preserves them as storage faults, not Owner evidence faults (§6.2).
+ *
+ * Spec: docs/superpowers/specs/2026-06-27-rulecode-context-vision-design.md §7.2
+ *
+ * Boundary: this module is I/O. Pure logic (type + validator) lives in
+ * `@principles/core/runtime-v2` → `behavior-example-pack.ts`.
+ */
+import { buildRuleHostAction } from '@principles/core/runtime-v2/internalization/rule-host-input-builder';
+import { computeBehaviorFacts } from '@principles/core/runtime-v2/internalization/rule-context-v2';
+import { validateBehaviorExamplePack } from '@principles/core/runtime-v2/internalization/behavior-example-pack';
+// Factory lives in evidence-readiness.ts (the classification authority); it is
+// consumed through its registered LEAF subpath. A VALUE import of the
+// runtime-v2 barrel on this satellite path re-pulls the whole LLM graph and
+// fails the satellite-purity guard (OPT-002, scripts/build/check-satellite-purity.mjs) —
+// the leaf is on core's exports allowlist for exactly this consumer.
+import { createOwnerEvidenceScopeError } from '@principles/core/runtime-v2/internalization/evidence-readiness';
+import { assembleBehaviorHistory } from './behavior-history.js';
+// ── internal constants ─────────────────────────────────────────────────────
+const MAX_POSITIVES = 3;
+const MAX_EVIDENCE_REFS = 5;
+const HISTORY_LIMIT = 100;
+const PROTO_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+/**
+ * PRI-980 review P2-1 (SPEC-PD-IAER-001 §6.2 case 3): the trajectory STORE
+ * throwing is an I/O/storage failure of the evidence source itself — it must
+ * surface as the typed `evidence_source_error` kind so the readiness contract
+ * preserves it as a storage fault instead of misreporting "Owner labelled bad
+ * evidence". Structural, never message sniffing: the store RETURNING no row
+ * is a data gap (the typed scope kinds below); the store THROWING is the I/O
+ * failure signal. Assembler-owned data-shape validation errors stay plain
+ * Errors (→ `invalid`), unchanged.
+ */
+function readTrajectoryStore(what, op) {
+    try {
+        return op();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw createOwnerEvidenceScopeError('evidence_source_error', `[BehaviorExamplePackAssembler] trajectory store ${what} failed (evidence source error, SPEC-PD-IAER-001 §6.2): ${message}`);
+    }
+}
+// ── type guards (rc-2: no `as` bypass) ─────────────────────────────────────
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function hasNoProtoKeys(value) {
+    for (const key of Object.keys(value)) {
+        if (PROTO_KEYS.has(key))
+            return false;
+    }
+    return true;
+}
+// ── BehaviorExamplePackAssembler ───────────────────────────────────────────
+/**
+ * Host-neutral assembler: pain lineage + trajectory → validated BehaviorExamplePack.
+ *
+ * The caller owns source lifecycle and supplies the real host vocabulary.
+ */
+function validateOwnerSelection(input) {
+    if (!Number.isSafeInteger(input.sourceNegativeToolCallId) || input.sourceNegativeToolCallId <= 0) {
+        throw new Error('[BehaviorExamplePackAssembler] sourceNegativeToolCallId must be a positive integer');
+    }
+    if (!Array.isArray(input.positiveToolCallIds) || input.positiveToolCallIds.length === 0 || input.positiveToolCallIds.length > MAX_POSITIVES) {
+        throw new Error('[BehaviorExamplePackAssembler] positiveToolCallIds must contain 1 to at most 3 IDs');
+    }
+    const allIds = [input.sourceNegativeToolCallId, ...input.positiveToolCallIds];
+    if (allIds.some((id) => !Number.isSafeInteger(id) || id <= 0) || new Set(allIds).size !== allIds.length) {
+        throw new Error('[BehaviorExamplePackAssembler] selected tool call IDs must be unique positive integers');
+    }
+}
+function requireSelectedRow(row, id) {
+    if (!row) {
+        // PRI-983: typed scope classification → stable `owner_behavior_examples_stale`
+        // at the readiness contract (the referenced trajectory row does not exist).
+        throw createOwnerEvidenceScopeError('tool_call_not_found', `[BehaviorExamplePackAssembler] selected tool call id=${id} not found`);
+    }
+    return row;
+}
+// ── internal: case builder ─────────────────────────────────────────────────
+/**
+ * Build a GoldenTraceCaseInput from a trajectory tool_call row.
+ *
+ * ERR-001: parses params_json as unknown and structurally validates (must be
+ * a plain object without proto-pollution keys). Throws on malformed input
+ * (rc-9: no silent fallback).
+ */
+function buildCaseFromRow(row, kind, expectedDecision) {
+    if (typeof row.toolName !== 'string' || row.toolName.length === 0) {
+        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: toolName must be a non-empty string (rc-9 fail loud)`);
+    }
+    if (typeof row.paramsJson !== 'string') {
+        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: paramsJson must be a string (rc-9 fail loud)`);
+    }
+    let parsedParams;
+    try {
+        parsedParams = JSON.parse(row.paramsJson);
+    }
+    catch {
+        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: paramsJson is not valid JSON (rc-9 fail loud)`);
+    }
+    if (!isPlainObject(parsedParams)) {
+        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: paramsJson must parse to a non-array object (rc-9 fail loud)`);
+    }
+    if (!hasNoProtoKeys(parsedParams)) {
+        throw new Error(`[BehaviorExamplePackAssembler] row id=${row.id}: paramsJson must not carry prototype-pollution keys (ERR-076, rc-9 fail loud)`);
+    }
+    return {
+        caseId: `case-${kind}-${row.id}`,
+        kind,
+        toolName: row.toolName,
+        params: parsedParams,
+        expectedDecision,
+    };
+}
+/**
+ * Redact sensitive fields from tool call params before they enter the pack.
+ *
+ * First-version policy:
+ *   - Absolute paths outside the project tree → replaced with `<redacted:absolute-path>`
+ *   - String values that look like secrets (long base64 / AKIA-style keys / etc.)
+ *     → replaced with `<redacted:secret>`
+ *
+ * Records each redaction in `notes` so the Artificer and the owner can see
+ * what was stripped (spec §7.2: redactionNotes is part of the pack contract).
+ */
+function looksLikeAbsolutePath(value) {
+    // POSIX absolute path or Windows drive path
+    return value.startsWith('/') || /^[A-Za-z]:[\\/]/.test(value);
+}
+const SECRET_PATTERNS = [
+    /AKIA[0-9A-Z]{16}/, // AWS access key ID
+    /[A-Za-z0-9+/]{40,}/, // long base64-ish token (≥40 chars, no spaces)
+];
+function looksLikeSecret(value) {
+    if (value.length < 20)
+        return false; // too short to be a real secret
+    for (const pattern of SECRET_PATTERNS) {
+        if (pattern.test(value))
+            return true;
+    }
+    return false;
+}
+function redactParams(params, projectDir) {
+    const notes = [];
+    const redacted = {};
+    for (const key of Object.keys(params)) {
+        if (PROTO_KEYS.has(key))
+            continue; // defense in depth (ERR-076)
+        const value = params[key];
+        if (typeof value !== 'string') {
+            redacted[key] = value;
+            continue;
+        }
+        // Path-like values
+        if (looksLikeAbsolutePath(value) && !value.startsWith(projectDir)) {
+            redacted[key] = '<redacted:absolute-path>';
+            notes.push(`redacted absolute path in field "${key}" (outside project tree)`);
+            continue;
+        }
+        // Secret-like values (AWS keys, long base64 tokens, etc.)
+        if (looksLikeSecret(value)) {
+            redacted[key] = '<redacted:secret>';
+            notes.push(`redacted possible secret in field "${key}"`);
+            continue;
+        }
+        redacted[key] = value;
+    }
+    return { redacted, notes };
+}
+export class BehaviorExamplePackAssembler {
+    db;
+    toolSemantics;
+    constructor(opts) {
+        this.db = opts.source;
+        this.toolSemantics = opts.toolSemantics;
+    }
+    /** Assemble only from explicit Owner labels; execution outcome is not a label. */
+    assemble(input) {
+        const pain = readTrajectoryStore(`pain lineage read for canonical_pain_id="${input.sourcePainId}"`, () => this.db.getPainEventByCanonicalId(input.sourcePainId));
+        if (!pain) {
+            // PRI-983: typed scope classification (structural marker — the readiness
+            // contract maps this to the stable `owner_behavior_examples_stale`
+            // code; FR-03: an unresolvable pain reference must never be silently
+            // reused). Message text unchanged (historical audit signature).
+            throw createOwnerEvidenceScopeError('pain_not_found', `[BehaviorExamplePackAssembler] pain event not found for canonical_pain_id="${input.sourcePainId}" (ERR-069 fail loud)`);
+        }
+        validateOwnerSelection(input);
+        const negativeRow = requireSelectedRow(readTrajectoryStore(`evidence row read for id=${input.sourceNegativeToolCallId}`, () => this.db.getRuleHostEvidenceRow(input.sourceNegativeToolCallId)), input.sourceNegativeToolCallId);
+        const positiveRows = input.positiveToolCallIds.map((id) => requireSelectedRow(readTrajectoryStore(`evidence row read for id=${id}`, () => this.db.getRuleHostEvidenceRow(id)), id));
+        for (const row of [negativeRow, ...positiveRows]) {
+            if (row.sessionId !== pain.sessionId) {
+                // PRI-983: cross pain/session selection → typed scope error → stable
+                // `owner_behavior_examples_scope_mismatch` at the readiness contract.
+                throw createOwnerEvidenceScopeError('session_mismatch', `[BehaviorExamplePackAssembler] selected tool call ${row.id} session mismatch; all examples must belong to pain session ${pain.sessionId}`);
+            }
+        }
+        const redactionNotes = [];
+        const buildCtx = { projectDir: input.projectDir, redactionNotes };
+        const sourceNegativeCase = this.buildSelectedCase(negativeRow, 'negative', buildCtx);
+        const positiveCounterexamples = positiveRows.map((row) => this.buildSelectedCase(row, 'positive', buildCtx));
+        const pack = {
+            sourceNegativeCase,
+            ownerDesiredOutcome: input.ownerDesiredOutcome,
+            positiveCounterexamples,
+            evidenceRefs: [`pain:${pain.id}`, `tool_call:${negativeRow.id}`, ...positiveRows.map((row) => `tool_call:${row.id}`)].slice(0, MAX_EVIDENCE_REFS),
+            redactionNotes,
+        };
+        // ── 9. Validate — fail loud (ERR-069) ──
+        const validation = validateBehaviorExamplePack(pack);
+        if (!validation.valid) {
+            throw new Error(`[BehaviorExamplePackAssembler] assembled pack failed validateBehaviorExamplePack: ${validation.errors.join('; ')} (ERR-069 fail loud)`);
+        }
+        return pack;
+    }
+    buildSelectedCase(row, kind, ctx) {
+        const { projectDir, redactionNotes } = ctx;
+        const base = buildCaseFromRow(row, kind, kind === 'negative' ? 'block' : 'allow');
+        const redaction = redactParams(base.params, projectDir);
+        redactionNotes.push(...redaction.notes);
+        const historyResult = readTrajectoryStore(`context history read for session=${row.sessionId} before id=${row.id}`, () => this.db.getRuleHostContextRowsBefore(row.sessionId, row.id, HISTORY_LIMIT));
+        const history = assembleBehaviorHistory(historyResult.rows, historyResult.truncated, { projectDir, toolSemantics: this.toolSemantics });
+        const action = buildRuleHostAction(row.toolName, redaction.redacted, projectDir, { canonicalKind: this.toolSemantics.resolve(row.toolName) });
+        const ruleContext = { version: 2, history, facts: computeBehaviorFacts(history, action.normalizedPath || null, null) };
+        return { ...base, params: redaction.redacted, ruleContext };
+    }
+}

package/host-runtime/dist/behavior-history.d.ts

@@ -0,0 +1,6 @@
+import type { RuleHistoryWindow, ToolSemanticRegistry } from '@principles/core/runtime-v2';
+import type { RuleHostContextRow } from '@principles/core/trajectory-types';
+export declare function assembleBehaviorHistory(rows: readonly RuleHostContextRow[], truncated: boolean, options: {
+    projectDir: string;
+    toolSemantics: ToolSemanticRegistry;
+}): RuleHistoryWindow;

package/host-runtime/dist/behavior-history.js

@@ -0,0 +1,76 @@
+/** Shared validated history assembly; host vocabulary is supplied by its owner. */
+import { extractFilePathFromParams, normalizePathPure } from '@principles/core/runtime-v2/internalization/rule-host-input-builder';
+const VALID_OUTCOMES = new Set(['success', 'failure', 'blocked']);
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isRuleToolOutcome(value) {
+    return typeof value === 'string' && VALID_OUTCOMES.has(value);
+}
+function unavailable(reason) {
+    return {
+        status: 'unavailable',
+        unavailableReason: reason,
+        truncated: false,
+        calls: [],
+    };
+}
+export function assembleBehaviorHistory(rows, truncated, options) {
+    const { projectDir, toolSemantics } = options;
+    const records = [];
+    for (const row of rows) {
+        // ── validate tool_name (ERR-001: unknown) ──
+        const { toolName } = row;
+        if (typeof toolName !== 'string' || toolName.length === 0) {
+            return unavailable(`row id=${row.id}: tool_name must be a non-empty string`);
+        }
+        // ── validate outcome (ERR-001: unknown, enum check) ──
+        const { outcome } = row;
+        if (!isRuleToolOutcome(outcome)) {
+            return unavailable(`row id=${row.id}: outcome "${row.outcome}" is not a valid RuleToolOutcome`);
+        }
+        // ── validate & parse params_json (ERR-001: unknown) ──
+        const paramsJsonStr = row.paramsJson;
+        if (typeof paramsJsonStr !== 'string') {
+            return unavailable(`row id=${row.id}: params_json must be a string`);
+        }
+        let parsedParams;
+        try {
+            parsedParams = JSON.parse(paramsJsonStr);
+        }
+        catch {
+            return unavailable(`row id=${row.id}: params_json is not valid JSON`);
+        }
+        // Must be a non-array object (spec §5.2)
+        if (!isPlainObject(parsedParams)) {
+            return unavailable(`row id=${row.id}: params_json must parse to a non-array object`);
+        }
+        // ── build RuleToolCallRecord ──
+        // PRI-634-F: resolve through the supplied registry (baseline + host
+        // layer) instead of baseline-only canonicalizeToolKind — production tools
+        // like 'shell'/'cmd'/'delete_file' previously degraded to 'other' here
+        // while the gate classified them as bash/write (vocabulary drift).
+        const canonicalKind = toolSemantics.resolve(toolName);
+        // Extract normalized path using the same pure logic as buildRuleHostAction
+        // (avoids production/replay drift, spec §4.4)
+        const rawPath = extractFilePathFromParams(parsedParams, {
+            isBashTool: canonicalKind === 'execute',
+            isWriteTool: canonicalKind === 'write',
+            toolName,
+        });
+        const normalizedPath = normalizePathPure(rawPath, projectDir);
+        records.push({
+            sequenceId: row.id,
+            toolName,
+            canonicalKind,
+            normalizedPath: normalizedPath === '' ? null : normalizedPath,
+            paramsSummary: parsedParams,
+            outcome,
+        });
+    }
+    return {
+        status: 'available',
+        truncated,
+        calls: records,
+    };
+}

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

@@ -85,3 +85,6 @@ export declare function createProductionHostRuntime(options?: Partial<Pick<HostR
      */
     events?: HostEventEmitter;
 }): HostRuntime;
+export * from './behavior-example-pack-assembler.js';
+export * from './behavior-history.js';
+export * from './workspace-behavior-evidence.js';

package/host-runtime/dist/index.js

@@ -265,3 +265,6 @@ export function createProductionHostRuntime(options = {}) {
         },
     });
 }
+export * from './behavior-example-pack-assembler.js';
+export * from './behavior-history.js';
+export * from './workspace-behavior-evidence.js';

package/host-runtime/dist/internalization-consumer-cycle.d.ts

@@ -20,7 +20,7 @@
  * Hosts inject: a logger, a structured-event sink, their tool catalog, and an
  * env getter. Everything else is the existing production path.
  */
-import { type ToolSemanticRegistry } from '@principles/core/runtime-v2';
+import { type ToolSemanticRegistry, type BehaviorEvidencePort } from '@principles/core/runtime-v2';
 import { type ConsumerGovernanceLogger } from './internalization-consumer-governance.js';
 export declare const INTERNALIZATION_AUTO_CONSUMER_FLAG_ID = "internalization_auto_consumer";
 /** Structural logger port — OpenClaw PluginLogger and worker loggers satisfy this. */
@@ -60,6 +60,17 @@ export interface InternalizationConsumerCyclePorts {
      * omitted → the artificer prompt is built without host context.
      */
     readonly hostKinds?: readonly string[];
+    /**
+     * PRI-982 (SPEC-PD-IAER-001 FR-02/FR-03): host-injected Owner evidence
+     * assembly for code_tool_hook artificer tasks. The production
+     * implementation (openclaw-plugin) wraps `BehaviorExamplePackAssembler`;
+     * hosts that cannot assemble evidence (Codex worker as of PRI-982) omit it.
+     * Absent port + a code-channel task degrades OBSERVABLY
+     * (evidence_source_unavailable) and the task STAYS PENDING — a host
+     * assembly gap must never read as "Owner has not labeled" (SPEC §6.2),
+     * and the runner is never constructed evidence-less.
+     */
+    readonly behaviorEvidence?: BehaviorEvidencePort;
     /** Log label used in human log prefixes ('AutoConsumer' | 'CodexWorker' | …). */
     readonly logLabel: string;
     readonly envGetter?: (name: string) => string | undefined;

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

@@ -23,7 +23,7 @@
 import { createRuntimeStateHandle, InternalizationOrchestrator, DreamerRunner, PhilosopherRunner, ScribeRunner, ArtificerRunner, buildArtificerHostSemanticContext, EvaluatorRunner, RolloutReviewerRunner, DefaultDreamerValidator, DefaultPhilosopherValidator, DefaultScribeValidator, DefaultArtificerValidator, DefaultEvaluatorValidator, DefaultRolloutReviewerValidator, PiAiRuntimeAdapter, L2AgentLoopAdapter, ArtificerL2Adapter, buildL2PrincipleReaderFromLedger, OpenClawCliRuntimeAdapter, storeEmitter, createProductionGateDeps, resolveRuntimeConfigFromPdConfig, resolveRuntimeConfigForAgent, AGENT_NAME_FOR_TASK_KIND, isRuntimeConfigError, computeConsumerDecision, FULL_CHAIN_CONSUMER_RUNNER_KINDS, DEFAULT_CONSUMER_RUNNER_KINDS, InternalizationQueueReadModel, MVP_CORE_TASK_KINDS, SqliteConnection, SqliteReconciliationCursorStore, SUCCEEDED_TRANSITIONS_SCOPE, PrincipleTreeLedgerAdapter, 
 // PRI-714: resolve outputLanguage from the same effective config the
 // runners already receive (EP-07: canonical resolved value, not raw input).
-resolveOutputLanguage, } from '@principles/core/runtime-v2';
+resolveOutputLanguage, hydratePITaskRecord, preflightArtificerOwnerEvidence, } from '@principles/core/runtime-v2';
 import { loadLedger } from '@principles/core/principle-tree-ledger';
 import { loadPdConfigForPlugin, loadFeatureFlagFromConfig } from './pd-config.js';
 import { createEvaluatorRepairDeps, createRolloutGovernanceDeps } from './internalization-consumer-governance.js';
@@ -296,6 +296,22 @@ export async function runInternalizationConsumerCycle(workspaceDir, ports) {
         // 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);
+        // PRI-634 A3: workspace-scoped telemetry sink. Constructed here (per-wake,
+        // workspaceDir in scope) so events from THIS workspace's runners are
+        // attributable to THIS workspace — a global subscriber on the storeEmitter
+        // singleton cannot (multi-workspace isolation, see
+        // workspace-telemetry-emitter.ts). Persist failures degrade through the
+        // host's structured event port, never break the runner.
+        // PRI-795 review P1: shared by the EvaluatorRunner AND the ArtificerL2
+        // adapter so `artificer_l2_complete` evidence (abortOwner/budget/elapsed/
+        // stopReason/tokenUsage) persists durably instead of vanishing with the
+        // process (the EP002-R3 "nothing recoverable after a failure" class).
+        const workspaceEmitter = new WorkspaceTelemetryEmitter(storeEmitter, workspaceDir, (detail) => {
+            emitEvent('WORKSPACE_TELEMETRY_PERSIST_FAILED', detail);
+        });
+        let artificerEvidence = null;
+        let authoritativeChannel = null;
+        let preflightSkipReason;
         for (const kind of orderedRunnerKinds) {
             const agentName = AGENT_NAME_FOR_TASK_KIND[kind];
             if (agentName === undefined) {
@@ -327,6 +343,109 @@ export async function runInternalizationConsumerCycle(workspaceDir, ports) {
             }
             const candidate = await orchestrator.wakeOnce(kind);
             if (candidate.decision === 'would_lease') {
+                // PRI-982 (SPEC-PD-IAER-001 §4.2 / FR-02): authoritative channel routing
+                // for artificer tasks. The channel is written deterministically by the
+                // intake bridge at seed time (pi_metadata.channel — the SINGLE authority,
+                // inherited along the chain) and is read from the leased task's hydrated
+                // metadata here; the cycle NEVER guesses it from task names or model text.
+                //   - code_tool_hook → RuleCode sub-chain: evidence preflight FIRST, then
+                //     L2 (flag permitting) with the assembled pack injected;
+                //   - prompt → the legal non-L2 pipeline (PiAi), evidence-exempt
+                //     (production: 40 successes on that pipeline);
+                //   - unresolvable → refuse to guess: observable skip, no run (T08).
+                const leasedTaskForChannel = await stateManager.getTask(candidate.taskId);
+                const leasedPiTask = leasedTaskForChannel ? hydratePITaskRecord(leasedTaskForChannel) : null;
+                authoritativeChannel = leasedPiTask?.channel ?? null;
+                if (candidate.taskKind === 'artificer') {
+                    if (authoritativeChannel === null || leasedPiTask === null) {
+                        // Defensive: wakeOnce never leases non-hydratable tasks, so reaching
+                        // here means the metadata corrupted between wake and read. Fail closed
+                        // — never route an artificer task without an authoritative channel.
+                        const channelInfo = JSON.stringify({
+                            reason: 'artificer_channel_unresolvable',
+                            taskId: candidate.taskId,
+                            nextAction: 'Inspect and repair the task metadata (pi_metadata.channel); the consumer refuses to route an artificer task without an authoritative channel (SPEC-PD-IAER-001 §4.2, T08).',
+                        });
+                        emitEvent('INTERNALIZATION_CONSUMER_SKIP', channelInfo);
+                        logger.warn(`[PD:${logLabel}] Artificer task ${candidate.taskId} skipped: authoritative channel unresolvable.`);
+                        preflightSkipReason = 'artificer_channel_unresolvable';
+                        continue;
+                    }
+                    if (authoritativeChannel === 'code_tool_hook') {
+                        // Capability OFF must block generation, not merely select L1.
+                        if (!loadFeatureFlagFromConfig(workspaceDir, 'code_rule_capability').enabled) {
+                            emitEvent('INTERNALIZATION_CONSUMER_SKIP', JSON.stringify({
+                                reason: 'code_rule_capability_disabled',
+                                taskId: candidate.taskId,
+                                taskKind: candidate.taskKind,
+                                nextAction: 'Owner must enable code_rule_capability before Code Rule generation.',
+                            }));
+                            logger.warn('[PD:' + logLabel + '] Code Rule task ' + candidate.taskId + ' paused: capability disabled.');
+                            preflightSkipReason = 'code_rule_capability_disabled';
+                            continue;
+                        }
+                        artificerEvidence = await preflightArtificerOwnerEvidence({
+                            taskId: candidate.taskId,
+                            piTask: leasedPiTask,
+                            owner,
+                            workspaceDir, // FR-08 run-correlation telemetry (PRI-984)
+                            stateManager,
+                            eventEmitter: workspaceEmitter,
+                            behaviorEvidence: ports.behaviorEvidence,
+                        });
+                        if (artificerEvidence.decision === 'evidence_source_unavailable') {
+                            // SPEC §6.2: a host assembly gap is NOT "Owner has not labeled".
+                            // The task stays pending (re-observable next cycle, zero model
+                            // cost); the runner is never constructed evidence-less.
+                            const gapInfo = JSON.stringify({
+                                reason: 'evidence_source_unavailable',
+                                taskId: candidate.taskId,
+                                taskKind: candidate.taskKind,
+                                nextAction: 'Host must wire the behaviorEvidence port (BehaviorExamplePackAssembler) into the consumer cycle ports; the task stays pending until then.',
+                            });
+                            emitEvent('INTERNALIZATION_CONSUMER_SKIP', gapInfo);
+                            logger.warn(`[PD:${logLabel}] Artificer task ${candidate.taskId} skipped: evidence source unavailable (host must wire the behaviorEvidence port).`);
+                            preflightSkipReason = 'evidence_source_unavailable';
+                            continue;
+                        }
+                        if (artificerEvidence.decision === 'evidence_source_error') {
+                            // PRI-980 review P2-1 — SPEC §6.2 case 3: a trajectory-store I/O
+                            // fault is preserved AS a storage fault. Same family as the absent
+                            // port: the task stays wake-eligible (the next cycle retries the
+                            // assembly at zero model cost), the runner is never constructed,
+                            // and the preflight already emitted the structured degradation
+                            // telemetry (reason=evidence_source_error, reviewPersisted=false).
+                            const storageInfo = JSON.stringify({
+                                reason: 'evidence_source_error',
+                                taskId: candidate.taskId,
+                                taskKind: candidate.taskKind,
+                                nextAction: artificerEvidence.nextAction,
+                                ...(artificerEvidence.detail !== undefined ? { detail: artificerEvidence.detail } : {}),
+                            });
+                            emitEvent('INTERNALIZATION_CONSUMER_SKIP', storageInfo);
+                            logger.warn(`[PD:${logLabel}] Artificer task ${candidate.taskId} skipped: evidence source error (storage fault preserved; task stays wake-eligible).`);
+                            preflightSkipReason = 'evidence_source_error';
+                            continue;
+                        }
+                        if (artificerEvidence.decision === 'blocked') {
+                            // FR-04: the preflight already moved the task atomically into
+                            // needs_human_review — outside the wake scan (pending/retry_wait
+                            // only), so it is never auto-rewoken (FR-05/T02). reviewPersisted
+                            // = false means a concurrent writer won the CAS; still no run.
+                            emitEvent('INTERNALIZATION_CONSUMER_EVIDENCE_BLOCKED', JSON.stringify({
+                                taskId: candidate.taskId,
+                                reasonCode: artificerEvidence.reasonCode,
+                                nextAction: artificerEvidence.nextAction,
+                                ...(artificerEvidence.missingFields !== undefined ? { missingFields: [...artificerEvidence.missingFields] } : {}),
+                                ...(artificerEvidence.detail !== undefined ? { detail: artificerEvidence.detail } : {}),
+                                reviewPersisted: artificerEvidence.reviewPersisted,
+                            }));
+                            logger.warn(`[PD:${logLabel}] Artificer task ${candidate.taskId} blocked on Owner evidence (${artificerEvidence.reasonCode}, reviewPersisted=${artificerEvidence.reviewPersisted}).`);
+                            preflightSkipReason = 'artificer_blocked_on_owner_evidence';
+                            continue;
+                        }
+                    }
+                }
                 wakeResult = candidate;
                 taskRuntimeConfig = kindRuntime;
                 break;
@@ -337,6 +456,10 @@ export async function runInternalizationConsumerCycle(workspaceDir, ports) {
             lastSkipReason = candidate.decision === 'no_ready_tasks' ? candidate.reason : undefined;
         }
         if (!wakeResult || taskRuntimeConfig === null) {
+            if (preflightSkipReason !== undefined) {
+                lastSkipDecision = preflightSkipReason;
+                lastSkipReason = undefined;
+            }
             // A: 预算由周期 finally 统一执行 (每周期恰一次,含 backlog 场景)
             const skipPayload = { decision: lastSkipDecision };
             if (lastSkipReason) {
@@ -349,19 +472,6 @@ export async function runInternalizationConsumerCycle(workspaceDir, ports) {
         // PRI-719: everything downstream reads the LEASED TASK's resolved config —
         // the kind-specific profile, not the shared gate resolution.
         const taskRuntimeKind = taskRuntimeConfig.runtimeKind;
-        // PRI-634 A3: workspace-scoped telemetry sink. Constructed here (per-wake,
-        // workspaceDir in scope) so events from THIS workspace's runners are
-        // attributable to THIS workspace — a global subscriber on the storeEmitter
-        // singleton cannot (multi-workspace isolation, see
-        // workspace-telemetry-emitter.ts). Persist failures degrade through the
-        // host's structured event port, never break the runner.
-        // PRI-795 review P1: shared by the EvaluatorRunner AND the ArtificerL2
-        // adapter so `artificer_l2_complete` evidence (abortOwner/budget/elapsed/
-        // stopReason/tokenUsage) persists durably instead of vanishing with the
-        // process (the EP002-R3 "nothing recoverable after a failure" class).
-        const workspaceEmitter = new WorkspaceTelemetryEmitter(storeEmitter, workspaceDir, (detail) => {
-            emitEvent('WORKSPACE_TELEMETRY_PERSIST_FAILED', detail);
-        });
         let adapter;
         if (taskRuntimeKind === 'pi-ai') {
             // PRI-419: when l2_dreamer flag is on AND this is a dreamer task, route
@@ -372,9 +482,15 @@ export async function runInternalizationConsumerCycle(workspaceDir, ports) {
             // so the model can self-iterate before submitting. Honors the
             // code_rule_capability emergency-disable flag (PR #1661 CodeRabbit P1).
             const codeRuleFlag = loadFeatureFlagFromConfig(workspaceDir, 'code_rule_capability');
+            // PRI-982 (SPEC-PD-IAER-001 §4.2): the authoritative TARGET CHANNEL is
+            // part of the L2 selection — `pi_metadata.channel === 'code_tool_hook'`
+            // (the seed-time bridge authority). prompt-channel artificer tasks are
+            // misroutes on L2 (production: 54 failures) and keep the legal non-L2
+            // PiAi pipeline below; unresolvable channels never enter L2.
             if (wakeResult.taskKind === 'artificer'
                 && taskRuntimeKind === 'pi-ai'
-                && codeRuleFlag.enabled) {
+                && codeRuleFlag.enabled
+                && authoritativeChannel === 'code_tool_hook') {
                 adapter = new ArtificerL2Adapter({
                     // Profile readiness check guarantees these are non-undefined for
                     // pi-ai runtime kind (validatePdLocalProfile enforces provider/model/apiKeyEnv).
@@ -518,7 +634,16 @@ export async function runInternalizationConsumerCycle(workspaceDir, ports) {
                 }, runnerOptions);
                 break;
             case 'artificer':
-                runner = new ArtificerRunner({ stateManager, runtimeAdapter: adapter, eventEmitter: storeEmitter, artifactStore: stateManager.piArtifactStore, validator: new DefaultArtificerValidator() }, 
+                runner = new ArtificerRunner({
+                    stateManager, runtimeAdapter: adapter, eventEmitter: storeEmitter, artifactStore: stateManager.piArtifactStore, validator: new DefaultArtificerValidator(),
+                    // PRI-982 (SPEC-PD-IAER-001 FR-02): the preflight-assembled Owner
+                    // evidence pack — present only when the authoritative channel is
+                    // code_tool_hook AND the readiness gate returned ready (same
+                    // ArtificerRunnerDeps shape as the run-rulehost CLI pipeline).
+                    ...(artificerEvidence !== null && artificerEvidence.decision === 'ready'
+                        ? { behaviorExamplePack: artificerEvidence.pack }
+                        : {}),
+                }, 
                 // PRI-741: thread the host semantic projection into generation.
                 { ...runnerOptions, ...(artificerHostSemanticContext !== undefined ? { hostSemanticContext: artificerHostSemanticContext } : {}) });
                 break;

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

@@ -0,0 +1,3 @@
+import type { BehaviorEvidencePort, ToolSemanticRegistry } from '@principles/core/runtime-v2';
+/** Lazy storage access: missing labels need no DB, and a failed open remains observable. */
+export declare function createWorkspaceBehaviorEvidencePort(workspaceDir: string, toolSemantics?: ToolSemanticRegistry): BehaviorEvidencePort;