create-principles-disciple 1.146.8 → 1.146.9

package/console/dist/server/routes/examiner-study-inputs.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Fixed server-side catalog. Each entry maps to a deterministic list of
+ * `makeExaminerV3Case` variants from the lab's authored calibration battery
+ * (`examiner-v07-cases.mjs`) — the same frozen assets the committed
+ * acceptance studies use. Case ids are minted per study by the executor.
+ */
+export declare const SUITE_CATALOG: readonly [{
+    readonly key: 'didactic-pair';
+    readonly title: 'Didactic pair (v0.9 default)';
+    readonly description: 'Two synthetic calibration cases: the canonical observe-then-report world plus the boundary (principle-not-applicable) variant. Same suite every v0.9 console study froze.';
+    readonly variants: readonly [{}, {
+        readonly boundary: true;
+    }];
+    readonly goldProvenance: 'SYNTHETIC_OFFLINE';
+}, {
+    readonly key: 'calibration-core';
+    readonly title: 'Calibration core (six worlds)';
+    readonly description: 'Six distinct worlds from the authored v0.7 calibration battery: canonical, boundary, deploy-cycle (owner signoff), unknown-evidence, preseeded-evidence and stale-source variants. Richer applicability mix; still SYNTHETIC gold.';
+    readonly variants: readonly [{}, {
+        readonly boundary: true;
+    }, {
+        readonly deploy: true;
+    }, {
+        readonly unknown: true;
+    }, {
+        readonly preseed: true;
+    }, {
+        readonly staleRequiredSource: true;
+    }];
+    readonly goldProvenance: 'SYNTHETIC_OFFLINE';
+}];
+export type SuiteKey = (typeof SUITE_CATALOG)[number]['key'];
+export declare const SUITE_KEYS: readonly string[];
+export interface SuiteCatalogEntry {
+    key: string;
+    title: string;
+    description: string;
+    caseCount: number;
+    variantLabels: string[];
+    goldProvenance: string;
+    goldGate: string;
+    suiteHash: string | null;
+}
+export declare function listSuiteCatalog(labRoot: string): Promise<SuiteCatalogEntry[]>;
+export declare function isSuiteKey(value: unknown): value is SuiteKey;
+/**
+ * Compile the case definitions for one suite under a STUDY-MINTED id prefix.
+ * The case ids are server-minted (`<studyId>-CASE-NN`); the request never
+ * contributes a case id or a path.
+ */
+export declare function suiteCaseDefs(labRoot: string, studyId: string, suiteKey: SuiteKey): Promise<Record<string, unknown>[]>;
+export interface ProductionSnapshot {
+    schema: 'examiner-production-snapshot.v1';
+    asOf: string;
+    targetPrincipleId: string;
+    promptRoute: {
+        status: 'confirmed' | 'unconfirmed';
+        routeName: string | null;
+        note: string;
+    };
+    budget: {
+        /** Production budget the projection actually resolved (UTF-16 chars). */
+        chars: number | null;
+        capacitySource: string | null;
+        capacityStatus: string | null;
+        policyVersion: string | null;
+        unit: 'utf16-chars';
+    };
+    runtimeActivation: {
+        /**
+         * The activation read model's own verdict ('ok' | 'degraded'). P1-2: a
+         * degraded read (missing state.db / table / unreadable) means the runtime
+         * truth is UNKNOWN — an empty row list here is NEVER "zero activations".
+         */
+        status: 'ok' | 'degraded';
+        reason?: string;
+        nextAction?: string;
+        /** Principles with an ACTIVE prompt activation row (runtime truth). */
+        promptActivePrincipleIds: string[];
+        /** Principles the production projection would inject right now. */
+        projectedInjectedPrincipleIds: string[] | null;
+        /** Bounded display list — NEVER the statistics basis (see ruleCodeCount). */
+        ruleCodeActivations: {
+            activationId: string;
+            principleId: string;
+            mode: string | null;
+            status: string;
+        }[];
+        /**
+         * P1-2: the COMPLETE workspace-wide code_tool_hook row count, computed
+         * before any display truncation (the UI list above is capped at 50).
+         */
+        ruleCodeActivationTotal: number;
+    };
+    ledgerActivePrincipleIds: string[];
+    divergence: {
+        /** Ledger-active principles with NO active runtime prompt activation. */
+        activeInLedgerNotRuntime: string[];
+        /** Ledger-active principles the current projection would NOT inject. */
+        activeInLedgerNotProjected: string[] | null;
+    };
+    targetPrinciple: {
+        runtimePromptActive: boolean;
+        projectedInjected: boolean | null;
+        ruleCodeActivationCount: number;
+        ledgerRuleCount: number;
+    };
+    experimentVsProduction: {
+        studyBudgetChars: number;
+        productionBudgetChars: number | null;
+        markers: string[];
+        note: string;
+    };
+}
+/** The single frozen marker for a configuration that is not the production injection path. */
+export declare const EXPERIMENT_CONFIG_MARKER = "EXPERIMENT_CONFIGURATION_DIFFERS_FROM_PRODUCTION";
+/**
+ * Gather the production facts a study must freeze at creation time. Every
+ * fact comes from an existing authority (projection / activation read model /
+ * ledger); nothing is inferred and nothing is written.
+ */
+export declare function gatherProductionSnapshot(workspaceDir: string, targetPrincipleId: string, studyBudgetChars: number): Promise<ProductionSnapshot>;
+export interface StudyRuleCodeFacts {
+    ruleCodes: {
+        ruleCodeId: string;
+        principleId: string;
+        baselineState: 'ON' | 'OFF';
+    }[];
+    principleRuleCodeIndependence: boolean | null;
+    targetRuleCodeCount: number;
+    evidenceNote: string;
+}
+/**
+ * Derive the study's RuleCode facts from RUNTIME activation rows
+ * (authoritative) cross-checked against the ledger rule count.
+ *
+ * Honesty rules (SPEC §7.2):
+ *   - a live-enforcing RuleCode bound to the target is a REAL coupling → the
+ *     count resolves but independence is unproven → INTERVENTION_NOT_IDENTIFIABLE
+ *     (the lab refuses creation; nothing is silently labelled principle_only);
+ *   - shadow (non-enforcing) rows resolve to baseline OFF — still a coupling
+ *     attribution, so independence stays unproven while any row exists;
+ *   - ledger-attributed rules with no runtime row stay UNRESOLVED (v0.9
+ *     semantics: unresolved baseline refuses, never assumed OFF).
+ */
+export declare function deriveStudyRuleCodeFacts(snapshot: ProductionSnapshot): StudyRuleCodeFacts;
+export declare function readProductionSnapshot(studyDir: string): Record<string, unknown> | null;

package/console/dist/server/routes/examiner-study-inputs.js

@@ -0,0 +1,263 @@
+/**
+ * SPEC-PD-EXAMINER-001 v0.10.1 §6/§9/§4 — host-backed study inputs.
+ *
+ * Assembles the REAL inputs a v0.10.1 study freezes:
+ *   - the Challenge Suite catalog (server-fixed keys over the lab's existing
+ *     authored case variants — no new authoring system, no request strings
+ *     crossing into the research pipeline: a request only SELECTS a key);
+ *   - the production snapshot (runtime activation truth + the production
+ *     prompt projection + budget provenance), frozen into the study as
+ *     `production-snapshot.json` so the report can state exactly where the
+ *     A/B starting point differs from production;
+ *   - RuleCode facts derived from RUNTIME activation rows (stronger evidence
+ *     than the ledger rule count alone; both are cross-checked and any
+ *     unresolved attribution stays a refusal — never an assumed OFF).
+ *
+ * Read-only against production: gathering a snapshot writes nothing outside
+ * the study directory the executor already owns.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { resolveLivePromptInjectionProjection } from '@principles/host-runtime';
+import { ActivationsConsoleModel } from '../models/ActivationsConsoleModel.js';
+import { PrinciplesConsoleModel } from '../models/PrinciplesConsoleModel.js';
+// ── Challenge Suite catalog (SPEC §9: reuse frozen research assets) ─────────
+/**
+ * Fixed server-side catalog. Each entry maps to a deterministic list of
+ * `makeExaminerV3Case` variants from the lab's authored calibration battery
+ * (`examiner-v07-cases.mjs`) — the same frozen assets the committed
+ * acceptance studies use. Case ids are minted per study by the executor.
+ */
+export const SUITE_CATALOG = [
+    {
+        key: 'didactic-pair',
+        title: 'Didactic pair (v0.9 default)',
+        description: 'Two synthetic calibration cases: the canonical observe-then-report world plus the boundary (principle-not-applicable) variant. Same suite every v0.9 console study froze.',
+        variants: [{}, { boundary: true }],
+        goldProvenance: 'SYNTHETIC_OFFLINE',
+    },
+    {
+        key: 'calibration-core',
+        title: 'Calibration core (six worlds)',
+        description: 'Six distinct worlds from the authored v0.7 calibration battery: canonical, boundary, deploy-cycle (owner signoff), unknown-evidence, preseeded-evidence and stale-source variants. Richer applicability mix; still SYNTHETIC gold.',
+        variants: [{}, { boundary: true }, { deploy: true }, { unknown: true }, { preseed: true }, { staleRequiredSource: true }],
+        goldProvenance: 'SYNTHETIC_OFFLINE',
+    },
+];
+export const SUITE_KEYS = SUITE_CATALOG.map((suite) => suite.key);
+/** Stable definition hash over the catalog entry (lab canonical hashing). */
+async function suiteDefinitionHash(labRoot, entry) {
+    try {
+        const freezeUrl = pathToFileURL(path.join(labRoot, 'lib', 'challenge-freeze.mjs')).href;
+        const freeze = (await import(freezeUrl));
+        return freeze.hashOfCanonical({ key: entry.key, variants: entry.variants, goldProvenance: entry.goldProvenance });
+    }
+    catch {
+        return null;
+    }
+}
+function variantLabel(variant) {
+    const flags = Object.keys(variant).filter((key) => variant[key] === true);
+    return flags.length > 0 ? flags.join('+') : 'canonical';
+}
+export async function listSuiteCatalog(labRoot) {
+    const entries = [];
+    for (const suite of SUITE_CATALOG) {
+        entries.push({
+            key: suite.key,
+            title: suite.title,
+            description: suite.description,
+            caseCount: suite.variants.length,
+            variantLabels: suite.variants.map((variant) => variantLabel(variant)),
+            goldProvenance: suite.goldProvenance,
+            goldGate: 'SYNTHETIC gold validates the offline contract only — formal real-behavior conclusions stay blocked behind Gate 1 (independent human Gold review)',
+            suiteHash: await suiteDefinitionHash(labRoot, suite),
+        });
+    }
+    return entries;
+}
+export function isSuiteKey(value) {
+    return typeof value === 'string' && SUITE_KEYS.includes(value);
+}
+/**
+ * Compile the case definitions for one suite under a STUDY-MINTED id prefix.
+ * The case ids are server-minted (`<studyId>-CASE-NN`); the request never
+ * contributes a case id or a path.
+ */
+export async function suiteCaseDefs(labRoot, studyId, suiteKey) {
+    const suite = SUITE_CATALOG.find((entry) => entry.key === suiteKey);
+    if (!suite)
+        throw new Error(`suiteCaseDefs: unknown suite key '${String(suiteKey)}'`);
+    const casesUrl = pathToFileURL(path.join(labRoot, 'lib', 'examiner-v07-cases.mjs')).href;
+    const mod = (await import(casesUrl));
+    return suite.variants.map((variant, index) => mod.makeExaminerV3Case({
+        ...variant,
+        caseId: `${studyId}-CASE-${String(index + 1).padStart(2, '0')}`,
+    }));
+}
+/** The single frozen marker for a configuration that is not the production injection path. */
+export const EXPERIMENT_CONFIG_MARKER = 'EXPERIMENT_CONFIGURATION_DIFFERS_FROM_PRODUCTION';
+/**
+ * Gather the production facts a study must freeze at creation time. Every
+ * fact comes from an existing authority (projection / activation read model /
+ * ledger); nothing is inferred and nothing is written.
+ */
+export async function gatherProductionSnapshot(workspaceDir, targetPrincipleId, studyBudgetChars) {
+    const asOf = new Date().toISOString();
+    // Production prompt projection — the SAME computation the runtime performs
+    // (route, budget, injected ids, selection policy).
+    const resolution = await resolveLivePromptInjectionProjection({ workspaceDir });
+    const confirmed = resolution.status === 'confirmed';
+    const projection = confirmed ? resolution.projection : null;
+    const perHost = confirmed ? [] : resolution.perHost;
+    const routeName = projection?.route ?? null;
+    const budgetChars = typeof projection?.budget === 'number' ? projection.budget : null;
+    const projectedInjectedIds = projection?.injectedPrincipleIds ?? null;
+    const budgetProvenance = projection ?? null;
+    // Runtime activation truth + ledger truth.
+    const activationsModel = new ActivationsConsoleModel(workspaceDir);
+    const activations = await activationsModel.getActivations();
+    const promptActivePrincipleIds = [...new Set(activations.activations
+            .filter((row) => row.channel === 'prompt' && row.status === 'active')
+            .map((row) => row.principleId))].sort();
+    const ruleCodeActivations = activations.activations
+        .filter((row) => row.channel === 'code_tool_hook')
+        .map((row) => ({ activationId: row.activationId, principleId: row.principleId, mode: row.mode ?? null, status: row.status }));
+    const principlesModel = new PrinciplesConsoleModel(workspaceDir);
+    const list = await principlesModel.listPrinciples();
+    const ledgerActivePrincipleIds = (list.principles ?? []).filter((p) => p.status === 'active').map((p) => p.id).sort();
+    const targetRules = activations.activations.filter((row) => row.principleId === targetPrincipleId && row.channel === 'code_tool_hook');
+    const ledgerTarget = (list.principles ?? []).find((p) => p.id === targetPrincipleId);
+    const activeInLedgerNotRuntime = ledgerActivePrincipleIds.filter((id) => !promptActivePrincipleIds.includes(id));
+    const activeInLedgerNotProjected = projectedInjectedIds === null
+        ? null
+        : ledgerActivePrincipleIds.filter((id) => !projectedInjectedIds.includes(id));
+    const markers = [];
+    if (budgetChars === null || budgetChars !== studyBudgetChars)
+        markers.push(EXPERIMENT_CONFIG_MARKER);
+    if (!confirmed)
+        markers.push('PROMPT_ROUTE_UNCONFIRMED_AT_FREEZE');
+    if (activeInLedgerNotProjected !== null && activeInLedgerNotProjected.length > 0) {
+        markers.push('PROJECTION_EVICTS_ACTIVE_LIBRARY_PRINCIPLES');
+    }
+    // P1-2: a degraded activation read is an Owner-visible freeze condition —
+    // the runtime truth is UNKNOWN, never "zero activations".
+    if (activations.status !== 'ok')
+        markers.push('ACTIVATION_DATA_DEGRADED');
+    return {
+        schema: 'examiner-production-snapshot.v1',
+        asOf,
+        targetPrincipleId,
+        promptRoute: {
+            status: confirmed ? 'confirmed' : 'unconfirmed',
+            routeName,
+            note: confirmed
+                ? 'the production injection route was resolved from workspace host facts at freeze time'
+                : `the production route could not be confirmed (${perHost.length} candidate host(s)) — the study freezes an unconfirmed-route baseline`,
+        },
+        budget: {
+            chars: budgetChars,
+            capacitySource: budgetProvenance?.budgetCapacitySource ?? null,
+            capacityStatus: budgetProvenance?.budgetCapacityStatus ?? null,
+            policyVersion: budgetProvenance?.budgetPolicyVersion ?? null,
+            unit: 'utf16-chars',
+        },
+        runtimeActivation: {
+            status: activations.status,
+            reason: activations.reason,
+            nextAction: activations.nextAction,
+            promptActivePrincipleIds,
+            projectedInjectedPrincipleIds: projectedInjectedIds,
+            ruleCodeActivations: ruleCodeActivations.slice(0, 50),
+            ruleCodeActivationTotal: ruleCodeActivations.length,
+        },
+        ledgerActivePrincipleIds,
+        divergence: {
+            activeInLedgerNotRuntime,
+            activeInLedgerNotProjected,
+        },
+        targetPrinciple: {
+            runtimePromptActive: promptActivePrincipleIds.includes(targetPrincipleId),
+            projectedInjected: projectedInjectedIds === null ? null : projectedInjectedIds.includes(targetPrincipleId),
+            ruleCodeActivationCount: targetRules.length,
+            ledgerRuleCount: ledgerTarget?.ruleCount ?? 0,
+        },
+        experimentVsProduction: {
+            studyBudgetChars,
+            productionBudgetChars: budgetChars,
+            markers,
+            note: 'the experiment renders arms under the frozen study budget with the offline deterministic renderer; the production prompt hook computes its own budget and selection — a marker above states every detected difference',
+        },
+    };
+}
+/**
+ * Derive the study's RuleCode facts from RUNTIME activation rows
+ * (authoritative) cross-checked against the ledger rule count.
+ *
+ * Honesty rules (SPEC §7.2):
+ *   - a live-enforcing RuleCode bound to the target is a REAL coupling → the
+ *     count resolves but independence is unproven → INTERVENTION_NOT_IDENTIFIABLE
+ *     (the lab refuses creation; nothing is silently labelled principle_only);
+ *   - shadow (non-enforcing) rows resolve to baseline OFF — still a coupling
+ *     attribution, so independence stays unproven while any row exists;
+ *   - ledger-attributed rules with no runtime row stay UNRESOLVED (v0.9
+ *     semantics: unresolved baseline refuses, never assumed OFF).
+ */
+export function deriveStudyRuleCodeFacts(snapshot) {
+    // P1-2: a degraded activation read means the runtime truth is UNKNOWN — an
+    // empty row list is NEVER "zero activations". Independence may only be the
+    // evidenced TRUE when the read model reported status=ok.
+    const activationDegraded = snapshot.runtimeActivation.status !== 'ok';
+    // ONLY the rows bound to the TARGET principle count as its coupling — a
+    // RuleCode activation for a DIFFERENT principle is part of the frozen
+    // baseline, not the target's intervention variable (SPEC §7.2).
+    const targetRows = activationDegraded
+        ? []
+        : snapshot.runtimeActivation.ruleCodeActivations
+            .filter((row) => row.principleId === snapshot.targetPrincipleId);
+    // Statistics come from the COMPLETE counts (never the 50-row display list):
+    // the snapshot freezes ruleCodeActivationTotal for the whole workspace and
+    // ruleCodeActivationCount for the target, both computed pre-truncation.
+    const targetRuleCodeCount = Math.max(snapshot.targetPrinciple.ruleCodeActivationCount, snapshot.targetPrinciple.ledgerRuleCount);
+    const resolved = targetRows.map((row) => ({
+        ruleCodeId: row.activationId,
+        principleId: snapshot.targetPrincipleId,
+        baselineState: row.mode === 'live' && row.status === 'active' ? 'ON' : 'OFF',
+    }));
+    const independence = !activationDegraded && targetRuleCodeCount === 0 ? true : null;
+    const degradedNote = activationDegraded
+        ? `RUNTIME ACTIVATION DATA DEGRADED (${snapshot.runtimeActivation.reason ?? 'unknown reason'}; next: ${snapshot.runtimeActivation.nextAction ?? 'inspect the workspace runtime state'}) — the activation truth is UNKNOWN, so independence is never assumed; ${snapshot.targetPrinciple.ledgerRuleCount} ledger-attributed rule(s) remain the only count evidence`
+        : null;
+    const evidenceNote = degradedNote
+        ?? (targetRuleCodeCount === 0
+            ? 'no RuleCode is attributed to the target principle by either the runtime activation table or the ledger — independence is an evidenced zero'
+            : `${targetRows.length} runtime RuleCode activation(s) and ${snapshot.targetPrinciple.ledgerRuleCount} ledger-attributed rule(s) bound to the TARGET; independent control of prompt injection while holding these at baseline is UNPROVEN — INTERVENTION_NOT_IDENTIFIABLE unless separately evidenced`);
+    return { ruleCodes: resolved, principleRuleCodeIndependence: independence, targetRuleCodeCount, evidenceNote };
+}
+/**
+ * Read a study's frozen production snapshot for DISPLAY (read-only; null when
+ * absent/unrecognized). The snapshot is frozen study data, not a trusted
+ * contract: the return type stays a plain untrusted record (rc-1) — no typed
+ * facade over parsed JSON.
+ */
+/** rc-1/rc-2: plain-object type guard over parsed JSON (no `as` narrowing). */
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function readProductionSnapshot(studyDir) {
+    const file = path.join(studyDir, 'production-snapshot.json');
+    if (!fs.existsSync(file))
+        return null;
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, 'utf8'));
+        if (!isPlainObject(parsed))
+            return null;
+        if (parsed.schema !== 'examiner-production-snapshot.v1')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}

package/console/dist/server/routes/examiner.d.ts

@@ -1,5 +1,5 @@
 /**
- * SPEC-PD-EXAMINER-001 v0.9 §8 — Examiner Console API (offline-first).
+ * SPEC-PD-EXAMINER-001 v0.9 §8 + v0.10.1 §4/§5/§6/§12 — Examiner Console API.
  *
  * Product entry for the Examiner research pipeline on top of the existing
  * principle-learning-lab (single research engine — no parallel Runner/Ledger/
@@ -7,34 +7,43 @@
  * (`console/lab`), so this surface is available in an installed runtime; a
  * developer checkout is served from the repository's scripts/dev/ lab.
  *
- * Offline only: every study carries SYNTHETIC_OFFLINE gold and is executed by
- * the deterministic local stub. Real model calls and real host runs stay
- * behind the Owner-authorization / Stage R gate and are refused here.
- *
- * Surface (all offline, zero real model/host calls):
- *   GET  /api/v1/examiner/overview                  — gates, host capability, study list
- *   GET  /api/v1/examiner/principles                — workspace principles as study inputs
- *   POST /api/v1/examiner/studies                   — create an offline examiner study
- *   GET  /api/v1/examiner/studies/:studyId          — manifest + execution + report status
- *   POST /api/v1/examiner/studies/:studyId/preflight — fail-closed preflight
- *   POST /api/v1/examiner/studies/:studyId/run      — offline-stub execution (real modes refused)
- *   GET  /api/v1/examiner/studies/:studyId/report   — Report V2 (read-only)
- *   POST /api/v1/examiner/studies/:studyId/report   — generate Report V2 (idempotent)
+ * Surface:
+ *   v0.9 (offline-first, semantics unchanged):
+ *     GET  /api/v1/examiner/overview
+ *     GET  /api/v1/examiner/principles
+ *     POST /api/v1/examiner/studies                   (v0.10.1: + suiteKey)
+ *     GET  /api/v1/examiner/studies/:studyId
+ *     POST /api/v1/examiner/studies/:studyId/preflight
+ *     POST /api/v1/examiner/studies/:studyId/run      (offline-stub, synchronous)
+ *     GET  /api/v1/examiner/studies/:studyId/report
+ *     POST /api/v1/examiner/studies/:studyId/report
+ *   v0.10.1:
+ *     GET  /api/v1/examiner/principles/:id/evidence   — production evidence aggregate
+ *     GET  /api/v1/examiner/suites                    — challenge-suite catalog
+ *     GET  /api/v1/examiner/hosts/openclaw/readiness  — host readiness projection
+ *     POST /api/v1/examiner/studies/:studyId/run      — modes 'host-dry-run' /
+ *       'f2-real-host' follow the §12.3 async contract: 202 + runId, state
+ *       derived from the study ledger, one live run per study, restart
+ *       recovery, RESULT_UNKNOWN never auto-retried, f2 gated on an APPROVED
+ *       Stage R authorization bound to the frozen study.
  *
  * Safety contract: this route layer contains NO filesystem access — every
  * study path is resolved inside examiner-executor by exact membership in the
  * server's own directory enumeration, and study identities are always
  * server-minted crypto-random handles. A request only SELECTS: the target
  * principle travels onward as an index into the server's own ledger list,
- * the experiment mode as a boolean. No request string crosses into the
- * research pipeline, and no request value constructs a path.
+ * the experiment mode as a boolean, the suite as a fixed-catalog key. No
+ * request string crosses into the research pipeline, no request value
+ * constructs a path, and no request value selects an executable.
  *
  * Two roots (P1-1): NEW console studies are WORKSPACE DATA — written under
  * `<workspace>/.pd/examiner/studies` — and require the server's own ownership
  * marker; the committed `examiner-studies/` research assets that travel with
  * the lab payload are visible but ALWAYS read-only here (POST /run and
  * POST /report answer 403). The frozen `challenge-studies/` area is never a
- * write target. Real-host execution is refused by this route class itself.
+ * write target. Real-host execution is refused until an APPROVED Stage R
+ * authorization exists inside the study — and the runner re-verifies that
+ * authority per unit regardless.
  */
 import type { IncomingMessage, ServerResponse } from 'node:http';
 /**