@principles/host-runtime 0.7.13 → 0.8.0

package/dist/active-principle-prompt.d.ts

@@ -1,4 +1,6 @@
 import { type ActivatedPrinciple, type PromptSelectionPolicy } from '@principles/core/runtime-v2';
+/** PRI-904 SPEC §10: bounded diagnostic id lists (mirrors the core selector's cap of 16). */
+export declare const MAX_SHARED_DIAGNOSTIC_IDS = 16;
 export interface ActivePrinciplePromptResult {
     additionalContext: string;
     principleIds: string[];

package/dist/active-principle-prompt.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { escapeXml } from '@principles/core/prompt-builder';
 import { loadPdConfigForPlugin } from './pd-config.js';
 /** PRI-904 SPEC §10: bounded diagnostic id lists (mirrors the core selector's cap of 16). */
-const MAX_SHARED_DIAGNOSTIC_IDS = 16;
+export const MAX_SHARED_DIAGNOSTIC_IDS = 16;
 /**
  * PR #1844 follow-up: the activation READ half of buildActivePrinciplePromptContext,
  * exported so the console budget projection can share the exact same input

package/dist/host-liveness-contract.d.ts

@@ -23,6 +23,33 @@ export type PromotionHostLivenessResolution = {
     hostRuntimeVersion: null;
     nextAction: string;
 };
+/**
+ * Workspace host-kind facts shared by every host-aware projection (prompt
+ * injection route resolution reuses the same two durable provenance sources
+ * as promotion liveness — one truth, no second registry):
+ * - `declaredKinds`: host-authored declarations under
+ *   `.pd/host-tool-semantics/<hostKind>.json` (each host writes its own file
+ *   on startup);
+ * - `evidenceKinds`: distinct `pain_events.host_kind` values in
+ *   trajectory.db (which hosts actually produced governance evidence here —
+ *   survives declaration deletion); pre-column tables carry no evidence by
+ *   construction;
+ * - `effectiveKinds`: union of both, sorted, deduplicated.
+ */
+export type WorkspaceHostKindFacts = {
+    readonly ok: true;
+    readonly declaredKinds: readonly string[];
+    readonly evidenceKinds: readonly string[];
+    readonly effectiveKinds: readonly string[];
+} | {
+    readonly ok: false;
+    readonly reason: 'host_declarations_unreadable' | 'workspace_provenance_unreadable';
+    /** Declarations that DID parse before the failure (empty when declarations themselves failed). */
+    readonly declaredKinds: readonly string[];
+    readonly detail: string;
+    readonly nextAction: string;
+};
+export declare function readWorkspaceHostKindFacts(workspaceDir: string): WorkspaceHostKindFacts;
 /**
  * PRI-813: resolve the promotion host-liveness contract from the workspace's
  * REAL host state instead of unconditionally inheriting the OpenClaw

package/dist/host-liveness-contract.js

@@ -72,6 +72,34 @@ function readWorkspaceHostProvenance(workspaceDir) {
 function promotionHostFailure(reason, hostKinds, nextAction) {
     return { ok: false, reason, hostKinds, hostContract: null, hostRuntimeVersion: null, nextAction };
 }
+export function readWorkspaceHostKindFacts(workspaceDir) {
+    const loaded = loadHostToolDeclarations(workspaceDir);
+    if (!loaded.ok && loaded.reason !== 'host_tool_declaration_missing') {
+        return {
+            ok: false,
+            reason: 'host_declarations_unreadable',
+            declaredKinds: [],
+            detail: `${loaded.reason} (${loaded.nextAction})`,
+            nextAction: `repair the host tool declarations before relying on host facts: ${loaded.reason} (${loaded.nextAction})`,
+        };
+    }
+    const declaredKinds = loaded.ok
+        ? [...new Set(loaded.declarations.map((declaration) => declaration.hostKind))].sort()
+        : [];
+    const provenance = readWorkspaceHostProvenance(workspaceDir);
+    if (!provenance.ok) {
+        return {
+            ok: false,
+            reason: 'workspace_provenance_unreadable',
+            declaredKinds,
+            detail: provenance.nextAction,
+            nextAction: provenance.nextAction,
+        };
+    }
+    const evidenceKinds = provenance.kinds.filter((kind) => kind === 'openclaw' || kind === 'codex');
+    const effectiveKinds = [...new Set([...declaredKinds, ...evidenceKinds])].sort();
+    return { ok: true, declaredKinds, evidenceKinds, effectiveKinds };
+}
 /**
  * PRI-813: resolve the promotion host-liveness contract from the workspace's
  * REAL host state instead of unconditionally inheriting the OpenClaw
@@ -107,19 +135,17 @@ function promotionHostFailure(reason, hostKinds, nextAction) {
  * truthfully over state that already exists.
  */
 export function resolvePromotionHostLiveness(workspaceDir) {
-    const loaded = loadHostToolDeclarations(workspaceDir);
-    if (!loaded.ok && loaded.reason !== 'host_tool_declaration_missing') {
-        return promotionHostFailure('host_declarations_unreadable', [], `repair the host tool declarations before promoting: ${loaded.reason} (${loaded.nextAction})`);
-    }
-    const declaredKinds = loaded.ok
-        ? [...new Set(loaded.declarations.map(declaration => declaration.hostKind))].sort()
-        : [];
-    const provenance = readWorkspaceHostProvenance(workspaceDir);
-    if (!provenance.ok) {
-        return promotionHostFailure('workspace_provenance_unreadable', declaredKinds, provenance.nextAction);
+    // Same two provenance sources and failure semantics as before, now via the
+    // shared facts reader (readWorkspaceHostKindFacts) so prompt-injection
+    // route resolution and promotion liveness cannot drift apart.
+    const facts = readWorkspaceHostKindFacts(workspaceDir);
+    if (!facts.ok) {
+        return promotionHostFailure(facts.reason, facts.declaredKinds, facts.reason === 'host_declarations_unreadable'
+            ? `repair the host tool declarations before promoting: ${facts.detail}`
+            : facts.nextAction);
     }
-    const provenanceKinds = provenance.kinds.filter(kind => kind === 'openclaw' || kind === 'codex');
-    const effectiveKinds = [...new Set([...declaredKinds, ...provenanceKinds])].sort();
+    const { declaredKinds } = facts;
+    const { effectiveKinds } = facts;
     // The promotion host can only be the OpenClaw contract when nothing on the
     // workspace — neither a declaration nor behavioral evidence — says Codex.
     if (!effectiveKinds.includes('codex')) {

package/dist/index.d.ts

@@ -6,6 +6,9 @@ import { type PainDatabaseFactory, type PainEnrichmentProvider } from './product
 import type { GovernanceHostKind, ToolSemanticRegistry } from '@principles/core/runtime-v2';
 export * from './active-principle-prompt.js';
 export * from './prompt-injection-projection.js';
+export * from './prompt-activation-deliverability.js';
+export * from './prompt-injection-status.js';
+export * from './prompt-injection-event-evidence.js';
 export * from './pd-config.js';
 export * from './production-rulehost-gate.js';
 export * from './rule-implementation-runtime.js';
@@ -30,6 +33,7 @@ export * from './codex-ingestion-consent.js';
 export * from './codex-worker-status.js';
 export * from './codex-legacy-registration.js';
 export * from './codex-transcript-locate.js';
+export * from './intervention-evidence-ingress.js';
 export declare const HOST_RUNTIME_ROUTES: readonly ['before_prompt_build', 'before_tool_call', 'after_tool_call'];
 export type HostRuntimeRoute = (typeof HOST_RUNTIME_ROUTES)[number];
 export type HostRuntimePort = (event: HostEvent) => HostEventResult | Promise<HostEventResult>;

package/dist/index.js

@@ -1,3 +1,4 @@
+import { randomUUID } from 'node:crypto';
 import { isHostEvent, isHostEventResult, } from '@principles/core/host';
 import { RUNTIME_V2_PRINCIPLE_BUDGET } from '@principles/core/runtime-v2';
 import { buildActivePrinciplePromptContext } from './active-principle-prompt.js';
@@ -5,6 +6,15 @@ import { createProductionRuleHostGate } from './production-rulehost-gate.js';
 import { createProductionPainEvidenceHandler } from './production-pain-evidence.js';
 export * from './active-principle-prompt.js';
 export * from './prompt-injection-projection.js';
+// SPEC PD_PROMPT_CAPACITY_V1: route-aware single-artifact deliverability
+// precheck (B1 write gate + A candidate fit) and the per-live-activation
+// injection status reader (A activation list). ONE implementation shared by
+// Console and CLI — no per-entry cost logic in either consumer.
+export * from './prompt-activation-deliverability.js';
+export * from './prompt-injection-status.js';
+// SPEC PD_PROMPT_CAPACITY_V1 Phase C (AC-12): honest read-model over the
+// existing injection-event JSONL — unknown vs proven-zero never conflated.
+export * from './prompt-injection-event-evidence.js';
 export * from './pd-config.js';
 export * from './production-rulehost-gate.js';
 export * from './rule-implementation-runtime.js';
@@ -49,6 +59,10 @@ export * from './codex-legacy-registration.js';
 // PRI-625 Slice D: transcript locator moved here so the §15 health service
 // computes per-rollout lag with the SAME locator the catch-up path uses.
 export * from './codex-transcript-locate.js';
+// PD v2 Phase 1: shared intervention evidence ingress — the ONE validated
+// entry point every host source (OpenClaw hooks, Codex pd-hook) uses to
+// append normalized evidence. Never throws; never delays a hook.
+export * from './intervention-evidence-ingress.js';
 export const HOST_RUNTIME_ROUTES = [
     'before_prompt_build',
     'before_tool_call',
@@ -212,6 +226,8 @@ export function createProductionHostRuntime(options = {}) {
                     skippedWarnings: prompt.warnings,
                     injectedCharCount: prompt.additionalContext.length,
                     budget: RUNTIME_V2_PRINCIPLE_BUDGET,
+                    ...(options.hostKind === 'openclaw' || options.hostKind === 'codex' ? { hostKind: options.hostKind } : {}),
+                    eventId: randomUUID(),
                     ...(prompt.truncated !== undefined ? { v2Truncated: prompt.truncated } : {}),
                     ...(event.context.turnId !== undefined ? { runId: event.context.turnId } : {}),
                     // PRI-904: selection diagnostics (bounded, optional). On this route

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

@@ -0,0 +1,41 @@
+import { type InterventionActivationOccurrenceRef, type InterventionContentRef, type InterventionEvidenceBatchInput } from '@principles/core/runtime-v2';
+export interface InterventionIngressAppendResult {
+    ok: boolean;
+    insertedCount?: number;
+    duplicateCount?: number;
+    conflictCount?: number;
+    reason?: string;
+    nextAction?: string;
+}
+export interface ExistingInterventionObservationSource {
+    sourceKind: 'openclaw_plugin_event_log' | 'codex_pd_hook_event_log';
+    sourceLocator: string;
+    observationKey: string;
+    principleId: string;
+    activationId: string;
+    artifactId?: string;
+}
+export interface InterventionEvidenceIngress {
+    /** Best-effort normalized append. Never throws. */
+    appendObservationBatch(input: {
+        workspaceDir: string;
+        batch: InterventionEvidenceBatchInput;
+    }): InterventionIngressAppendResult;
+    /** Evidence scope id for a governance workspace (stable per workspace). */
+    evidenceScopeIdFor(workspaceDir: string): string;
+    /** Digest the actual governed artifact content, not activation metadata. */
+    resolveInterventionContentRef(workspaceDir: string, activationRef: InterventionActivationOccurrenceRef, principleId: string): InterventionContentRef | null;
+    /**
+     * Resolve the activation occurrence metadata snapshot. The snapshot digest
+     * is not a Principle content digest; use resolveInterventionContentRef for
+     * the artifact's actual bytes.
+     */
+    resolveActivationOccurrenceRef(workspaceDir: string, activationId: string): InterventionActivationOccurrenceRef | null;
+    /** Reuse the exact references already persisted for an idempotent source key. */
+    existingObservationRefs(workspaceDir: string, source: ExistingInterventionObservationSource): {
+        activationRef: InterventionActivationOccurrenceRef;
+        contentRef: InterventionContentRef;
+    } | null;
+}
+export declare function createInterventionEvidenceIngress(): InterventionEvidenceIngress;
+export declare function getInterventionEvidenceIngress(): InterventionEvidenceIngress;

package/dist/intervention-evidence-ingress.js

@@ -0,0 +1,272 @@
+/**
+ * Intervention Evidence Ingress — the single normalized entry point every
+ * runtime source uses to append intervention evidence (PD v2 Phase 1,
+ * ADR-0027 §2.3; SPEC §13.7 "统一入口").
+ *
+ * Host adapters build observation batches; ONLY this module validates,
+ * normalizes and persists them. No adapter writes evidence tables directly.
+ *
+ * Failure contract (SPEC §13.7): evidence persistence failure must NEVER
+ * change an already computed tool allow/deny. The ingress never throws —
+ * every failure returns a structured result with reason + nextAction, and
+ * the durable raw source (event log / receipt ledger rows) stays available
+ * for bounded replay. The writer connection uses busyTimeoutMs: 0, so a
+ * contended state.db lock surfaces immediately as storage_unavailable
+ * instead of delaying a hook.
+ *
+ * Scope identity (SPEC §13.3): evidence_scope_id is persisted in the local
+ * evidence ledger and reused after workspace relocation. A canonical path
+ * only provides a deterministic candidate when a ledger has no scope yet.
+ */
+import { createHash } from 'node:crypto';
+import { isAbsolute, resolve } from 'node:path';
+import { realpathSync } from 'node:fs';
+import { normalizeInterventionEvidenceBatch, SqliteConnection, SqliteInterventionEvidenceStore, } from '@principles/core/runtime-v2';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export function createInterventionEvidenceIngress() {
+    function scopeIdCandidateFor(workspaceDir) {
+        const absolute = isAbsolute(workspaceDir) ? resolve(workspaceDir) : resolve(process.cwd(), workspaceDir);
+        // Resolve aliases before using the path as a first-append candidate. Once
+        // persisted, the database scope remains authoritative across relocations.
+        let resolved = absolute;
+        try {
+            resolved = realpathSync(absolute);
+        }
+        catch { /* keep absolute */ }
+        return `pd-evidence-scope:sha256:${createHash('sha256').update(resolved, 'utf8').digest('hex').slice(0, 32)}`;
+    }
+    function evidenceScopeIdFor(workspaceDir) {
+        const candidate = scopeIdCandidateFor(workspaceDir);
+        let connection = null;
+        try {
+            connection = new SqliteConnection({ workspaceDir, readonly: true, bootstrapIfMissing: false });
+            const established = new SqliteInterventionEvidenceStore(connection).getEvidenceScope();
+            if (established)
+                return established.scopeId;
+        }
+        catch {
+            // A missing or unreadable read-only database cannot confirm a persisted
+            // scope; return an uncached candidate and let the writer recheck.
+        }
+        finally {
+            try {
+                connection?.close();
+            }
+            catch { /* best-effort */ }
+        }
+        return candidate;
+    }
+    function resolveInterventionContentRef(workspaceDir, activationRef, principleId) {
+        if (!activationRef.artifactId)
+            return null;
+        let connection = null;
+        try {
+            connection = new SqliteConnection({ workspaceDir, readonly: true, bootstrapIfMissing: false });
+            const db = connection.getDb();
+            // A replay may refer to a deactivated occurrence. Its current artifact
+            // bytes cannot prove what was injected at the historical event time.
+            // Resolve content only while the exact activation occurrence is live.
+            const occurrence = db.prepare(`
+        SELECT 1 FROM activations
+        WHERE activation_id = ? AND idempotency_key = ? AND deactivated_at IS NULL
+      `).get(activationRef.activationId, activationRef.idempotencyKey ?? '');
+            if (!occurrence)
+                return null;
+            const row = db.prepare('SELECT content_json, source_principle_id FROM pi_artifacts WHERE artifact_id = ?').get(activationRef.artifactId);
+            if (!isRecord(row)
+                || typeof row.content_json !== 'string'
+                || row.source_principle_id !== principleId)
+                return null;
+            return {
+                principleId,
+                artifactId: activationRef.artifactId,
+                payloadDigest: `sha256:${createHash('sha256').update(row.content_json, 'utf8').digest('hex')}`,
+                resolution: 'resolved',
+            };
+        }
+        catch {
+            return null;
+        }
+        finally {
+            try {
+                connection?.close();
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    function appendObservationBatch(input) {
+        const normalization = normalizeInterventionEvidenceBatch(input.batch);
+        if (!normalization.ok) {
+            return {
+                ok: false,
+                reason: `evidence_batch_rejected:${normalization.reason}`,
+                nextAction: 'Fix the producer payload; nothing was written. The raw source remains durable.',
+            };
+        }
+        let connection = null;
+        try {
+            connection = new SqliteConnection({ workspaceDir: input.workspaceDir, busyTimeoutMs: 0 });
+            const store = new SqliteInterventionEvidenceStore(connection);
+            const expectedScope = store.getEvidenceScope()?.scopeId ?? scopeIdCandidateFor(input.workspaceDir);
+            if (input.batch.evidenceScopeId !== expectedScope) {
+                return {
+                    ok: false,
+                    reason: `evidence_scope_mismatch:${input.batch.evidenceScopeId}`,
+                    nextAction: 'Resolve the evidence scope for this workspace and rebuild the batch before replay; no records were written.',
+                };
+            }
+            const result = store.appendObservationBatch(normalization.batch);
+            return {
+                ok: result.ok,
+                insertedCount: result.insertedCount,
+                duplicateCount: result.duplicates.length,
+                conflictCount: result.conflicts.length,
+                ...(result.reason !== undefined ? { reason: result.reason } : {}),
+                ...(result.nextAction !== undefined ? { nextAction: result.nextAction } : {}),
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                reason: `evidence_storage_failed:${message}`,
+                nextAction: 'The raw source remains durable; replay the same observation batch later — idempotency makes replay safe.',
+            };
+        }
+        finally {
+            try {
+                connection?.close();
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    function resolveActivationOccurrenceRef(workspaceDir, activationId) {
+        let connection = null;
+        try {
+            connection = new SqliteConnection({ workspaceDir, readonly: true, bootstrapIfMissing: false });
+            const db = connection.getDb();
+            const activationRows = db.prepare(`
+        SELECT activation_id, idempotency_key, artifact_id, channel, action, target_ref, activated_at, deactivated_at
+        FROM activations
+        WHERE activation_id = ?
+        ORDER BY activated_at DESC
+      `).all(activationId);
+            // Without the source's activation-time snapshot, reused ids cannot be
+            // matched to one historical row safely. Keep this as an explicit gap.
+            if (activationRows.length !== 1)
+                return null;
+            const activationRow = activationRows[0];
+            if (!isRecord(activationRow))
+                return null;
+            const artifactId = typeof activationRow.artifact_id === 'string' ? activationRow.artifact_id : null;
+            let artifactDigest = null;
+            // A deactivated activation row proves occurrence metadata, but the
+            // artifact table only exposes current content, not an as-activated copy.
+            if (artifactId && activationRow.deactivated_at == null) {
+                const artifactRow = db.prepare(`
+          SELECT artifact_id, artifact_kind, source_task_id, source_principle_id, source_rule_id,
+                 lineage_artifact_ids, validation_status, content_json, created_at, updated_at
+          FROM pi_artifacts WHERE artifact_id = ?
+        `).get(artifactId);
+                if (isRecord(artifactRow) && typeof artifactRow.content_json === 'string') {
+                    // Digest the governed artifact bytes exactly as captured — this is
+                    // the content the approval/activation authority owns (SPEC §13.3).
+                    artifactDigest = `sha256:${createHash('sha256').update(artifactRow.content_json, 'utf8').digest('hex')}`;
+                }
+            }
+            const snapshotBody = {
+                activationId,
+                idempotencyKey: activationRow.idempotency_key ?? null,
+                artifactId,
+                channel: activationRow.channel ?? null,
+                action: activationRow.action ?? null,
+                activatedAt: activationRow.activated_at ?? null,
+                artifactDigest,
+            };
+            // An activation row can survive after its artifact has been removed.
+            // Its metadata snapshot remains useful, but it is not a content digest.
+            return {
+                activationId,
+                ...(typeof activationRow.idempotency_key === 'string' ? { idempotencyKey: activationRow.idempotency_key } : {}),
+                ...(artifactId !== null ? { artifactId } : {}),
+                ...(typeof activationRow.channel === 'string' ? { channel: activationRow.channel } : {}),
+                ...(typeof activationRow.activated_at === 'string' ? { activatedAt: activationRow.activated_at } : {}),
+                sourceSnapshotDigest: `sha256:${createHash('sha256').update(JSON.stringify(snapshotBody), 'utf8').digest('hex')}`,
+            };
+        }
+        catch {
+            // Resolution is best-effort metadata for the evidence reference; an
+            // unreadable store leaves the caller to record the honest gap.
+            return null;
+        }
+        finally {
+            try {
+                connection?.close();
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    function existingObservationRefs(workspaceDir, source) {
+        let connection = null;
+        try {
+            connection = new SqliteConnection({ workspaceDir, readonly: true, bootstrapIfMissing: false });
+            const row = connection.getDb().prepare(`
+        SELECT activation_ref_json, content_ref_json
+        FROM intervention_evidence_records WHERE source_kind = ? AND source_locator = ? AND observation_key = ?
+      `).get(source.sourceKind, source.sourceLocator, source.observationKey);
+            if (!isRecord(row) || typeof row.activation_ref_json !== 'string' || typeof row.content_ref_json !== 'string')
+                return null;
+            const activationRaw = JSON.parse(row.activation_ref_json);
+            const contentRaw = JSON.parse(row.content_ref_json);
+            const validDigest = (value) => typeof value === 'string' && /^sha256:[a-f0-9]{64}$/.test(value);
+            if (!isRecord(activationRaw) || typeof activationRaw.activationId !== 'string'
+                || !validDigest(activationRaw.sourceSnapshotDigest)
+                || !isRecord(contentRaw) || typeof contentRaw.principleId !== 'string'
+                || (contentRaw.resolution !== 'resolved' && contentRaw.resolution !== 'revision_reference_unresolved')
+                || (contentRaw.resolution === 'resolved' && !validDigest(contentRaw.payloadDigest))
+                || (contentRaw.resolution === 'revision_reference_unresolved' && contentRaw.payloadDigest !== undefined))
+                return null;
+            if (activationRaw.activationId !== source.activationId || contentRaw.principleId !== source.principleId
+                || (typeof activationRaw.artifactId === 'string' && contentRaw.artifactId !== activationRaw.artifactId)
+                || (source.artifactId !== undefined && (activationRaw.artifactId !== source.artifactId
+                    || contentRaw.artifactId !== source.artifactId)))
+                return null;
+            const activationRef = {
+                activationId: activationRaw.activationId,
+                sourceSnapshotDigest: activationRaw.sourceSnapshotDigest,
+                ...(typeof activationRaw.idempotencyKey === 'string' ? { idempotencyKey: activationRaw.idempotencyKey } : {}),
+                ...(typeof activationRaw.artifactId === 'string' ? { artifactId: activationRaw.artifactId } : {}),
+                ...(typeof activationRaw.channel === 'string' ? { channel: activationRaw.channel } : {}),
+                ...(typeof activationRaw.activatedAt === 'string' ? { activatedAt: activationRaw.activatedAt } : {}),
+            };
+            const contentRef = {
+                principleId: contentRaw.principleId,
+                resolution: contentRaw.resolution,
+                ...(typeof contentRaw.artifactId === 'string' ? { artifactId: contentRaw.artifactId } : {}),
+                ...(typeof contentRaw.version === 'string' ? { version: contentRaw.version } : {}),
+                ...(typeof contentRaw.payloadDigest === 'string' ? { payloadDigest: contentRaw.payloadDigest } : {}),
+                ...(typeof contentRaw.approvalRef === 'string' ? { approvalRef: contentRaw.approvalRef } : {}),
+            };
+            return { activationRef, contentRef };
+        }
+        catch {
+            return null;
+        }
+        finally {
+            try {
+                connection?.close();
+            }
+            catch { /* best-effort */ }
+        }
+    }
+    return { appendObservationBatch, evidenceScopeIdFor, resolveInterventionContentRef, resolveActivationOccurrenceRef, existingObservationRefs };
+}
+/** Process-wide default ingress. */
+let defaultIngress = null;
+export function getInterventionEvidenceIngress() {
+    if (!defaultIngress)
+        defaultIngress = createInterventionEvidenceIngress();
+    return defaultIngress;
+}

package/dist/prompt-activation-deliverability.d.ts

@@ -0,0 +1,106 @@
+import { type ActivatedPrinciple } from '@principles/core/runtime-v2';
+import { PROMPT_INJECTION_UNIT, type PromptInjectionBudgetScope, type PromptInjectionRouteDecision, type PromptInjectionRouteName, type PromptInjectionTargetHost } from './prompt-injection-projection.js';
+/**
+ * SPEC PD_PROMPT_CAPACITY_V1 R-B2: ONE route-aware single-artifact capacity
+ * precheck, shared by every real prompt-activation write entry (Console
+ * approve, CLI approve) and by the pre-approval candidate fit (R-A2). The
+ * cost is measured with the SAME production serializer/selector the bound
+ * route uses — list route bills the selected-lines entry (header + entry),
+ * shared route bills the full single-principle directive render including
+ * the self-report footer when that flag is on. The principle identity is
+ * the REAL resolved id (content `principleId` or draft title) — never a
+ * fixed-length UUID allowance (a title-derived id can only be longer).
+ *
+ * This module deliberately does NOT read host configs from core: it lives
+ * in host-runtime and consumes the workspace config + host facts here.
+ */
+export interface PromptDeliverabilityCandidateArtifact {
+    artifactId: string;
+    artifactKind: string;
+    contentJson: string;
+    validationStatus: string;
+}
+export type PromptArtifactDeliverability = {
+    status: 'deliverable';
+    route: PromptInjectionRouteName;
+    hostKind?: PromptInjectionTargetHost;
+    basis?: PromptInjectionRouteDecision['basis'];
+    budget: number;
+    /** Single-item cost in UTF-16 code units under the bound route's serializer. */
+    costChars: number;
+    budgetScope: PromptInjectionBudgetScope;
+    unit: typeof PROMPT_INJECTION_UNIT;
+} | {
+    status: 'undeliverable';
+    reason: 'single_item_exceeds_budget';
+    route: PromptInjectionRouteName;
+    hostKind?: PromptInjectionTargetHost;
+    basis?: PromptInjectionRouteDecision['basis'];
+    budget: number;
+    costChars: number;
+    overByChars: number;
+    budgetScope: PromptInjectionBudgetScope;
+    unit: typeof PROMPT_INJECTION_UNIT;
+    nextAction: string;
+} | {
+    status: 'unconfirmed';
+    /** Stable machine-readable reason (route facts or artifact content unresolvable). */
+    reason: string;
+    nextAction: string;
+    /** Route-unconfirmed case: per-host single-item fit so the UI can show both. */
+    perHost?: readonly {
+        hostKind: PromptInjectionTargetHost;
+        fits: boolean;
+        costChars: number;
+    }[];
+};
+/** Resolve the REAL principle identity + text from the artifact content. */
+export declare function resolvePromptCandidatePrinciple(artifact: PromptDeliverabilityCandidateArtifact): {
+    ok: true;
+    principle: ActivatedPrinciple;
+} | {
+    ok: false;
+    warning: string;
+};
+/**
+ * Positive single-item evidence under a given route, using the production
+ * selector itself (AC-06: a row is "fits" because its own serialized entry
+ * fits — never because it is absent from a bounded diagnostic list).
+ *
+ * `costChars` is what the single-entry selection would consume, measured the
+ * same way the route's projection reports `usedChars` (the joined selected
+ * lines). For an entry that does NOT fit, trimToBudget returns only the
+ * header line, so the would-be cost is reconstructed from the header line it
+ * DID return plus the real entry line (same format authority, listEntryLine).
+ */
+export declare function computePromptSingleItemFit(input: {
+    principle: ActivatedPrinciple;
+    route: PromptInjectionRouteName;
+    selfReportEnabled: boolean;
+}): {
+    fits: boolean;
+    costChars: number;
+};
+/**
+ * Precheck one artifact against the workspace's effective injection route.
+ * Pure read — no state mutation, safe to call before any governance write.
+ */
+export declare function checkPromptArtifactDeliverability(input: {
+    workspaceDir: string;
+    targetHost?: PromptInjectionTargetHost;
+    artifact: PromptDeliverabilityCandidateArtifact | null | undefined;
+}): Promise<PromptArtifactDeliverability>;
+/** Load one artifact read-only from `<workspace>/.pd/state.db`. Failures carry a reason (rc-9). */
+export declare function loadPromptArtifactById(workspaceDir: string, artifactId: string): Promise<{
+    ok: true;
+    artifact: PromptDeliverabilityCandidateArtifact;
+} | {
+    ok: false;
+    reason: string;
+}>;
+/** Combined load + precheck for write gates that only hold an artifact id (CLI approve). */
+export declare function checkPromptArtifactDeliverabilityById(input: {
+    workspaceDir: string;
+    artifactId: string;
+    targetHost?: PromptInjectionTargetHost;
+}): Promise<PromptArtifactDeliverability>;