create-principles-disciple 1.147.8 → 1.147.9

package/host-runtime/dist/active-principle-prompt.js

@@ -3,6 +3,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { escapeXml } from '@principles/core/prompt-builder';
 import { loadPdConfigForPlugin } from './pd-config.js';
+import { readPromptActivationAuthority } from './prompt-activation-authority.js';
+import { revalidateAdaptivePrinciple } from './adaptive-principle-revalidation.js';
 /** PRI-904 SPEC §10: bounded diagnostic id lists (mirrors the core selector's cap of 16). */
 export const MAX_SHARED_DIAGNOSTIC_IDS = 16;
 /**
@@ -34,7 +36,10 @@ export async function readPromptActivationCandidates(input) {
         return { principles, warnings, aborted: true, selfReportEnabled, abstractionLayerEnabled };
     }
     try {
-        connection = new SqliteConnection({ workspaceDir: input.workspaceDir, readonly: true, bootstrapIfMissing: false });
+        connection = new SqliteConnection({ workspaceDir: input.workspaceDir, readonly: true, bootstrapIfMissing: false,
+            // Additional adaptive reads must not hold the host behind SQLite's synchronous busy wait.
+            ...(input.includeAuthority === true ? { busyTimeoutMs: 0 } : {}),
+        });
         const activations = filterPromptActivations(await new SqliteActivationStateStore(connection).listPromptActivations());
         const artifactStore = new SqlitePIArtifactStore(connection);
         for (const activation of activations) {
@@ -61,6 +66,19 @@ export async function readPromptActivationCandidates(input) {
                 warnings.push(resolved.warning);
                 continue;
             }
+            if (input.includeAuthority === true) {
+                try {
+                    const authority = readPromptActivationAuthority(connection, artifact.artifactId, 'prompt');
+                    if (authority.authority)
+                        resolved.principle.authority = authority.authority;
+                    if (authority.approvedBy)
+                        resolved.principle.approvedBy = authority.approvedBy;
+                }
+                catch {
+                    // Approval lookup failure is unknown, never inferred as owner or policy.
+                    warnings.push(`prompt_activation_authority_unavailable: artifactId=${artifact.artifactId}`);
+                }
+            }
             principles.push(resolved.principle);
         }
     }
@@ -84,6 +102,11 @@ export async function buildActivePrinciplePromptContext(input) {
             additionalContext: '', principleIds: [], activationIds: [], artifactIds: [], warnings,
             budget: budgetChars, truncated: false,
             selectionPolicy: 'legacy_fifo_prefix_v1', eligibleCount: 0,
+            ...(input.adaptivePriority ? { adaptivePacking: {
+                    status: 'unavailable', reason: 'reader_aborted',
+                    targetActivationId: input.adaptivePriority.activationId, targetArtifactId: input.adaptivePriority.artifactId,
+                    displacedActivationIds: [], ...(input.hookInvocationId ? { hookInvocationId: input.hookInvocationId } : {}),
+                } } : {}),
             budgetCapacitySource: promptBudget.capacitySource,
             budgetCapacityStatus: promptBudget.capacityStatus,
             budgetContextWindowTokens: promptBudget.contextWindowTokens,
@@ -92,9 +115,6 @@ export async function buildActivePrinciplePromptContext(input) {
             ...(promptBudget.fallbackDetail !== undefined ? { budgetFallbackDetail: promptBudget.fallbackDetail } : {}),
         };
     }
-    const included = [];
-    let additionalContext = '';
-    let truncated = false;
     // PRI-904: same fair-rotation semantics as the plugin route's trimToBudget —
     // deterministic rotating start over the base (ASC) candidate order, circular
     // scan, continue-on-non-fit. Costs are measured with the REAL serializer
@@ -108,56 +128,149 @@ export async function buildActivePrinciplePromptContext(input) {
     const rotationStartIndex = selectionPolicy === 'fair_rotation_v1' && roundKey !== undefined
         ? ((roundKey % n) + n) % n
         : undefined;
-    const droppedActivationIds = [];
-    const oversizedActivationIds = [];
-    const standaloneFits = (principle) => renderPrinciplesToDirectives([principle], new Set([principle.principleId]), { escapeFn: escapeXml, selfReportInstruction: selfReportEnabled }).length
-        <= budgetChars;
-    const scanOrder = rotationStartIndex === undefined
+    const nativeScanOrder = rotationStartIndex === undefined
         ? principles
         : principles.slice(rotationStartIndex).concat(principles.slice(0, rotationStartIndex));
-    for (const principle of scanOrder) {
-        const candidate = [...included, principle];
-        const candidateContext = renderPrinciplesToDirectives(candidate, new Set(candidate.map((entry) => entry.principleId)), { escapeFn: escapeXml, selfReportInstruction: selfReportEnabled });
-        if (candidateContext.length > budgetChars) {
-            if (standaloneFits(principle)) {
-                // Fits alone but not now — normal budget truncation.
-                truncated = true;
-                if (droppedActivationIds.length < MAX_SHARED_DIAGNOSTIC_IDS)
-                    droppedActivationIds.push(principle.activationId);
-            }
-            else if (oversizedActivationIds.length < MAX_SHARED_DIAGNOSTIC_IDS) {
-                // Can never fit alone — oversize, not starvation (PRI-904 SPEC §6.6).
-                oversizedActivationIds.push(principle.activationId);
+    const pack = (scanOrder) => {
+        const included = [];
+        let additionalContext = '';
+        let truncated = false;
+        const dropped = [];
+        const oversized = [];
+        const standaloneFits = (principle) => renderPrinciplesToDirectives([principle], new Set([principle.principleId]), { escapeFn: escapeXml, selfReportInstruction: selfReportEnabled }).length
+            <= budgetChars;
+        for (const principle of scanOrder) {
+            const candidate = [...included, principle];
+            const candidateContext = renderPrinciplesToDirectives(candidate, new Set(candidate.map((entry) => entry.principleId)), { escapeFn: escapeXml, selfReportInstruction: selfReportEnabled });
+            if (candidateContext.length > budgetChars) {
+                if (standaloneFits(principle)) {
+                    truncated = true;
+                    if (dropped.length < MAX_SHARED_DIAGNOSTIC_IDS)
+                        dropped.push(principle.activationId);
+                }
+                else if (oversized.length < MAX_SHARED_DIAGNOSTIC_IDS) {
+                    oversized.push(principle.activationId);
+                }
+                if (selectionPolicy === 'legacy_fifo_prefix_v1')
+                    break;
+                continue;
             }
-            if (selectionPolicy === 'legacy_fifo_prefix_v1')
-                break;
-            continue;
+            included.push(principle);
+            additionalContext = candidateContext;
         }
-        included.push(principle);
-        additionalContext = candidateContext;
+        return { included, additionalContext, truncated, dropped, oversized };
+    };
+    const makeResult = (packing, eligiblePrinciples, adaptivePacking) => {
+        const resultWarnings = [...warnings];
+        if (packing.truncated) {
+            resultWarnings.push('prompt_context_truncated: production_prompt_cap; nextAction=reduce_active_prompt_principles');
+        }
+        const injectedIds = new Set(packing.included.map((principle) => principle.principleId));
+        return {
+            additionalContext: packing.additionalContext,
+            principleIds: [...injectedIds],
+            activationIds: packing.included.map((principle) => principle.activationId),
+            artifactIds: packing.included.map((principle) => principle.artifactId),
+            warnings: resultWarnings,
+            budget: budgetChars,
+            truncated: packing.truncated,
+            selectionPolicy,
+            eligibleCount: eligiblePrinciples.length,
+            ...(rotationStartIndex !== undefined ? { rotationStartIndex } : {}),
+            ...(packing.dropped.length > 0 ? { droppedActivationIds: packing.dropped } : {}),
+            ...(packing.oversized.length > 0 ? { oversizedActivationIds: packing.oversized } : {}),
+            budgetCapacitySource: promptBudget.capacitySource,
+            budgetCapacityStatus: promptBudget.capacityStatus,
+            budgetContextWindowTokens: promptBudget.contextWindowTokens,
+            budgetPolicyVersion: promptBudget.policyVersion,
+            ...(promptBudget.fallbackReason !== undefined ? { budgetFallbackReason: promptBudget.fallbackReason } : {}),
+            ...(promptBudget.fallbackDetail !== undefined ? { budgetFallbackDetail: promptBudget.fallbackDetail } : {}),
+            ...(adaptivePacking ? { adaptivePacking } : {}),
+        };
+    };
+    const nativePacking = pack(nativeScanOrder);
+    const nativeResult = makeResult(nativePacking, principles);
+    const priority = input.adaptivePriority;
+    if (priority === undefined)
+        return nativeResult;
+    const report = (status, reason, displacedActivationIds = []) => ({
+        status,
+        ...(reason ? { reason } : {}),
+        targetActivationId: typeof priority.activationId === 'string' ? priority.activationId : '',
+        targetArtifactId: typeof priority.artifactId === 'string' ? priority.artifactId : '',
+        ...(input.hookInvocationId ? { hookInvocationId: input.hookInvocationId } : {}),
+        displacedActivationIds,
+    });
+    const nativeTargetMatches = principles.filter((principle) => principle.artifactId === priority.artifactId && principle.activationId === priority.activationId);
+    const [nativeTarget] = nativeTargetMatches;
+    const baselineHasTarget = nativePacking.included.some((principle) => principle.artifactId === priority.artifactId && principle.activationId === priority.activationId);
+    const withoutTarget = (reason) => {
+        if (nativeTargetMatches.length !== 1 || !nativeTarget)
+            return { ...nativeResult, adaptivePacking: report('unavailable', reason) };
+        const targetPrincipleId = nativeTarget.principleId;
+        const safePrinciples = principles.filter((principle) => principle.principleId !== targetPrincipleId);
+        const safeScanOrder = nativeScanOrder.filter((principle) => principle.principleId !== targetPrincipleId);
+        const safePacking = pack(safeScanOrder);
+        return makeResult(safePacking, safePrinciples, report('unavailable', reason, baselineHasTarget ? [nativeTarget.activationId] : []));
+    };
+    if (typeof priority.artifactId !== 'string' || !priority.artifactId.trim()
+        || typeof priority.activationId !== 'string' || !priority.activationId.trim()) {
+        return { ...nativeResult, adaptivePacking: report('unavailable', 'invalid_target') };
     }
-    if (truncated) {
-        warnings.push('prompt_context_truncated: production_prompt_cap; nextAction=reduce_active_prompt_principles');
+    if (nativeTargetMatches.length === 0)
+        return { ...nativeResult, adaptivePacking: report('unavailable', 'target_unavailable') };
+    if (nativeTargetMatches.length !== 1)
+        return { ...nativeResult, adaptivePacking: report('unavailable', 'target_ambiguous') };
+    if (!nativeTarget)
+        return { ...nativeResult, adaptivePacking: report('unavailable', 'target_unavailable') };
+    if (principles.filter((principle) => principle.principleId === nativeTarget.principleId).length !== 1) {
+        return { ...nativeResult, adaptivePacking: report('unavailable', 'target_ambiguous') };
     }
-    const injectedIds = new Set(included.map((principle) => principle.principleId));
-    return {
-        additionalContext,
-        principleIds: [...injectedIds],
-        activationIds: included.map((principle) => principle.activationId),
-        artifactIds: included.map((principle) => principle.artifactId),
-        warnings,
-        budget: budgetChars,
-        truncated,
-        selectionPolicy,
-        eligibleCount: principles.length,
-        ...(rotationStartIndex !== undefined ? { rotationStartIndex } : {}),
-        ...(droppedActivationIds.length > 0 ? { droppedActivationIds } : {}),
-        ...(oversizedActivationIds.length > 0 ? { oversizedActivationIds } : {}),
-        budgetCapacitySource: promptBudget.capacitySource,
-        budgetCapacityStatus: promptBudget.capacityStatus,
-        budgetContextWindowTokens: promptBudget.contextWindowTokens,
-        budgetPolicyVersion: promptBudget.policyVersion,
-        ...(promptBudget.fallbackReason !== undefined ? { budgetFallbackReason: promptBudget.fallbackReason } : {}),
-        ...(promptBudget.fallbackDetail !== undefined ? { budgetFallbackDetail: promptBudget.fallbackDetail } : {}),
-    };
+    const authorityRead = await readPromptActivationCandidates({ workspaceDir: input.workspaceDir, includeAuthority: true });
+    const authorizedMatches = authorityRead.principles.filter((principle) => principle.artifactId === priority.artifactId && principle.activationId === priority.activationId);
+    const [authorizedTarget] = authorizedMatches;
+    if (authorityRead.aborted || authorityRead.warnings.length > 0 || authorizedMatches.length !== 1 || !authorizedTarget
+        || authorityRead.principles.filter((principle) => principle.principleId === authorizedTarget.principleId).length !== 1) {
+        return withoutTarget('authority_unavailable');
+    }
+    if (!authorizedTarget.authority
+        || authorizedTarget.principleId !== nativeTarget.principleId
+        || authorizedTarget.text !== nativeTarget.text
+        || authorizedTarget.artifactContentSha256 !== nativeTarget.artifactContentSha256) {
+        return withoutTarget('target_changed');
+    }
+    const signal = input.signal ?? new AbortController().signal;
+    const targetRendered = renderPrinciplesToDirectives([nativeTarget], new Set([nativeTarget.principleId]), { escapeFn: escapeXml });
+    const targetBody = targetRendered.slice(targetRendered.indexOf('<directive '), targetRendered.indexOf('</directive>') + '</directive>'.length);
+    const prepared = (status, displaced = []) => ({
+        ...report(status, undefined, displaced), targetSnapshot: authorizedTarget, targetBody,
+        nativeBaseline: nativeResult, ...(input.deadlineAt !== undefined ? { deadlineAt: input.deadlineAt } : {}),
+    });
+    if (baselineHasTarget) {
+        const stillValid = await revalidateAdaptivePrinciple(input.workspaceDir, authorizedTarget, signal);
+        if (!stillValid)
+            return withoutTarget('target_changed');
+        return { ...nativeResult, adaptivePacking: prepared('target_present') };
+    }
+    const targetIndex = nativeScanOrder.indexOf(nativeTarget);
+    const targetFirstScan = [nativeTarget, ...nativeScanOrder.filter((principle, index) => index !== targetIndex && principle.principleId !== nativeTarget.principleId)];
+    const prioritizedPacking = pack(targetFirstScan);
+    if (!prioritizedPacking.included.some((principle) => principle.principleId === nativeTarget.principleId)) {
+        return { ...nativeResult, adaptivePacking: report('unavailable', 'target_does_not_fit') };
+    }
+    const mandatoryIds = input.mandatoryPrincipleIds ?? [];
+    if (!Array.isArray(mandatoryIds) || mandatoryIds.some((id) => typeof id !== 'string')
+        || mandatoryIds.some((id) => !prioritizedPacking.included.some((principle) => principle.principleId === id))) {
+        return { ...nativeResult, adaptivePacking: report('unavailable', 'mandatory_constraint_displaced') };
+    }
+    const stillValid = await revalidateAdaptivePrinciple(input.workspaceDir, authorizedTarget, signal);
+    if (!stillValid)
+        return { ...nativeResult, adaptivePacking: report('unavailable', 'target_changed') };
+    const prioritizedActivationIds = new Set(prioritizedPacking.included.map((principle) => principle.activationId));
+    const displacedActivationIds = nativePacking.included
+        .filter((principle) => !prioritizedActivationIds.has(principle.activationId))
+        .map((principle) => principle.activationId);
+    const result = makeResult(prioritizedPacking, principles, prepared('prioritized', displacedActivationIds));
+    // Adaptive assembly is deliberately limited to the existing renderer's Native budget cap.
+    return result;
 }

package/host-runtime/dist/adaptive-principle-revalidation.d.ts

@@ -0,0 +1,8 @@
+import { type PromptActivationCandidates } from './active-principle-prompt.js';
+import type { ActivatedPrinciple } from '@principles/core/runtime-v2';
+export type AdaptivePrincipleReader = (input: {
+    workspaceDir: string;
+}) => Promise<PromptActivationCandidates>;
+/** Bind a test or host-specific reader while keeping the production call signature minimal. */
+export declare function createAdaptivePrincipleRevalidator(reader: AdaptivePrincipleReader): (workspaceDir: string, expected: ActivatedPrinciple, signal: AbortSignal) => Promise<boolean>;
+export declare function revalidateAdaptivePrinciple(workspaceDir: string, expected: ActivatedPrinciple, signal: AbortSignal): Promise<boolean>;

package/host-runtime/dist/adaptive-principle-revalidation.js

@@ -0,0 +1,52 @@
+import { readPromptActivationCandidates, } from './active-principle-prompt.js';
+/**
+ * Rechecks the rendered principle's identity, body, and authorization at the
+ * adaptive-intervention return boundary. A full artifact digest is required;
+ * legacy snapshots without it cannot certify a stable artifact revision.
+ */
+async function revalidateWithReader(input, reader) {
+    const { workspaceDir, expected, signal } = input;
+    if (signal.aborted || !expected.artifactContentSha256 || !/^[a-f0-9]{64}$/.test(expected.artifactContentSha256))
+        return false;
+    let onAbort;
+    const aborted = new Promise((resolve) => {
+        onAbort = () => resolve(null);
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted)
+            onAbort();
+    });
+    try {
+        const result = await Promise.race([reader({ workspaceDir }), aborted]);
+        if (!result || signal.aborted || result.aborted || result.warnings.length > 0)
+            return false;
+        const matches = result.principles.filter((candidate) => candidate.artifactId === expected.artifactId && candidate.activationId === expected.activationId);
+        if (matches.length !== 1)
+            return false;
+        const [current] = matches;
+        if (!current)
+            return false;
+        // Duplicate principle identity is ambiguous even if one activation pair matches.
+        if (result.principles.filter((candidate) => candidate.principleId === expected.principleId).length !== 1)
+            return false;
+        return current.principleId === expected.principleId
+            && current.artifactContentSha256 === expected.artifactContentSha256
+            && current.text === expected.text
+            && current.authority === expected.authority
+            && current.approvedBy === expected.approvedBy;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        if (onAbort)
+            signal.removeEventListener('abort', onAbort);
+    }
+}
+/** Bind a test or host-specific reader while keeping the production call signature minimal. */
+export function createAdaptivePrincipleRevalidator(reader) {
+    return (workspaceDir, expected, signal) => revalidateWithReader({ workspaceDir, expected, signal }, reader);
+}
+export function revalidateAdaptivePrinciple(workspaceDir, expected, signal) {
+    const readWithAuthority = ({ workspaceDir: currentWorkspaceDir }) => readPromptActivationCandidates({ workspaceDir: currentWorkspaceDir, includeAuthority: true });
+    return revalidateWithReader({ workspaceDir, expected, signal }, readWithAuthority);
+}

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

@@ -5,6 +5,7 @@ import type { RuleImplementationRuntime } from './rule-implementation-runtime.js
 import { type PainDatabaseFactory, type PainEnrichmentProvider } from './production-pain-evidence.js';
 import type { GovernanceHostKind, ToolSemanticRegistry } from '@principles/core/runtime-v2';
 export * from './active-principle-prompt.js';
+export * from './prompt-activation-authority.js';
 export * from './prompt-injection-projection.js';
 export * from './prompt-activation-deliverability.js';
 export * from './prompt-injection-status.js';
@@ -76,6 +77,20 @@ export declare function createProductionHostRuntime(options?: Partial<Pick<HostR
     projectDir?: string;
     /** PRI-634-F: host-declared tool semantics supplied by the constructing host adapter. */
     toolSemantics?: ToolSemanticRegistry;
+    /** Optional, already-scoped single prompt target from the host adapter. Errors fail closed to Native. */
+    adaptivePriorityProvider?: (event: HostEvent) => {
+        artifactId: string;
+        activationId: string;
+        hookInvocationId?: string;
+        signal?: AbortSignal;
+        deadlineAt?: number;
+    } | undefined | Promise<{
+        artifactId: string;
+        activationId: string;
+        hookInvocationId?: string;
+        signal?: AbortSignal;
+        deadlineAt?: number;
+    } | undefined>;
     /**
      * PRI-750: optional event emission port. When present, the shared-path
      * handlers record injection/tool events carrying the host's natural
@@ -96,3 +111,4 @@ export * from './explicit-owner-statement-prefix.js';
 export { listObservedDesignGateSessions } from './workspace-behavior-evidence.js';
 export { readDesignGateSpecSnapshot, describeCodexRuleContextFact } from './design-gate-facts.js';
 export { createCodexArtificerTrustedFactsPort } from './codex-artificer-trusted-facts.js';
+export { revalidateAdaptivePrinciple, createAdaptivePrincipleRevalidator, type AdaptivePrincipleReader } from './adaptive-principle-revalidation.js';

package/host-runtime/dist/index.js

@@ -6,6 +6,7 @@ import { buildActivePrinciplePromptContext } from './active-principle-prompt.js'
 import { createProductionRuleHostGate } from './production-rulehost-gate.js';
 import { createProductionPainEvidenceHandler } from './production-pain-evidence.js';
 export * from './active-principle-prompt.js';
+export * from './prompt-activation-authority.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
@@ -225,8 +226,35 @@ export function createProductionHostRuntime(options = {}) {
             const declaredWindow = promptBudgetHostKind === undefined
                 ? undefined
                 : operatorDeclaredContextWindow(loadPdConfigForPlugin(event.context.workspaceDir).effective.config.promptBudget, promptBudgetHostKind);
+            let adaptivePriority;
+            let skippedPriority;
+            if (options.adaptivePriorityProvider) {
+                try {
+                    adaptivePriority = await options.adaptivePriorityProvider(event);
+                    if (adaptivePriority && (typeof adaptivePriority.artifactId !== 'string' || !adaptivePriority.artifactId.trim()
+                        || typeof adaptivePriority.activationId !== 'string' || !adaptivePriority.activationId.trim()
+                        || (adaptivePriority.deadlineAt !== undefined && !Number.isFinite(adaptivePriority.deadlineAt)))) {
+                        adaptivePriority = undefined;
+                    }
+                    if (adaptivePriority?.signal?.aborted
+                        || (adaptivePriority?.deadlineAt !== undefined && Date.now() >= adaptivePriority.deadlineAt)) {
+                        skippedPriority = adaptivePriority;
+                        adaptivePriority = undefined;
+                    }
+                }
+                catch {
+                    // An optional adaptive provider can never alter the ordinary Native path on failure.
+                    adaptivePriority = undefined;
+                }
+            }
             const prompt = await buildActivePrinciplePromptContext({
                 workspaceDir: event.context.workspaceDir,
+                ...(adaptivePriority ? {
+                    adaptivePriority: { artifactId: adaptivePriority.artifactId, activationId: adaptivePriority.activationId },
+                    ...(adaptivePriority.signal ? { signal: adaptivePriority.signal } : {}),
+                    ...(adaptivePriority.deadlineAt !== undefined ? { deadlineAt: adaptivePriority.deadlineAt } : {}),
+                    ...(adaptivePriority.hookInvocationId ? { hookInvocationId: adaptivePriority.hookInvocationId } : {}),
+                } : {}),
                 promptBudget: resolvePromptBudget({
                     // SPEC-PD-MODEL-AWARE-PROMPT-BUDGET-001: resolve ONCE per request
                     // from the host's own hook facts (OpenClaw effective window /
@@ -250,6 +278,11 @@ export function createProductionHostRuntime(options = {}) {
                     catalog: getPromptModelCatalog(),
                 }),
             });
+            if (skippedPriority?.hookInvocationId)
+                prompt.adaptivePacking = {
+                    status: 'unavailable', reason: 'deadline', targetActivationId: skippedPriority.activationId,
+                    targetArtifactId: skippedPriority.artifactId, hookInvocationId: skippedPriority.hookInvocationId, displacedActivationIds: [],
+                };
             // PRI-750: record the injection event on the shared path with the host
             // turn id (Codex turn_id → runId) so receipt events carry a turn-level
             // anchor in the same events_*.jsonl format as the OpenClaw path. The
@@ -326,3 +359,4 @@ export * from './explicit-owner-statement-prefix.js';
 export { listObservedDesignGateSessions } from './workspace-behavior-evidence.js';
 export { readDesignGateSpecSnapshot, describeCodexRuleContextFact } from './design-gate-facts.js';
 export { createCodexArtificerTrustedFactsPort } from './codex-artificer-trusted-facts.js';
+export { revalidateAdaptivePrinciple, createAdaptivePrincipleRevalidator } from './adaptive-principle-revalidation.js';

package/host-runtime/dist/prompt-activation-authority.d.ts

@@ -0,0 +1,7 @@
+import type { SqliteConnection } from '@principles/core/runtime-v2';
+export interface PromptActivationAuthority {
+    authority?: 'owner' | 'system_policy';
+    approvedBy?: string;
+}
+/** Read the existing approval row without changing how activation is granted. */
+export declare function readPromptActivationAuthority(sqliteConn: Pick<SqliteConnection, 'getDb'>, artifactId: string, channel: string): PromptActivationAuthority;

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

@@ -0,0 +1,16 @@
+/** Read the existing approval row without changing how activation is granted. */
+export function readPromptActivationAuthority(sqliteConn, artifactId, channel) {
+    const row = sqliteConn.getDb().prepare(`
+    SELECT decided_by FROM approvals
+    WHERE artifact_id = ? AND channel = ? AND status = 'approved'
+    ORDER BY decided_at DESC LIMIT 1
+  `).get(artifactId, channel);
+    if (row !== null && typeof row === 'object' && Object.hasOwn(row, 'decided_by')) {
+        const decidedBy = row.decided_by;
+        return {
+            authority: 'owner',
+            approvedBy: typeof decidedBy === 'string' && decidedBy.length > 0 ? decidedBy : undefined,
+        };
+    }
+    return { authority: 'system_policy' };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-principles-disciple",
-  "version": "1.147.8",
+  "version": "1.147.9",
   "description": "Interactive CLI installer for Principles Disciple OpenClaw plugin",
   "type": "module",
   "bin": {
@@ -101,5 +101,5 @@
   "pd": {
     "bundledPluginVersion": "2.6.1"
   },
-  "gitHead": "d9bbe994104eac08a8a41fa1c9374f28dc629aec"
+  "gitHead": "75c6765405cfb763e52c2b558e80a76deb96e3f6"
 }

package/pd-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@principles/pd-cli",
-  "version": "1.164.0",
+  "version": "1.165.0",
   "description": "PD CLI — Pain recording, sample management, and governance tasks for Principles Disciple",
   "type": "module",
   "bin": {