create-principles-disciple 1.147.8 → 1.147.10

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-journal-reconciliation.d.ts

@@ -0,0 +1,205 @@
+/**
+ * PRI-1109 — conservative, read-only reconciliation of adaptive-delivery journal
+ * records (approved design: docs/specs/PD-AA-PRI-1109-JOURNAL-RECONCILE-DESIGN-v0.2.md).
+ *
+ * Semantic red lines enforced here:
+ * - closed/reconciled is a recorded phase, never success;
+ * - payload=confirmed and submission are only transcribed as recorded evidence
+ *   declarations (never re-verified by this reader);
+ * - an absent terminal, absent start, or absent log is "not visible in the
+ *   scanned range", never a claim about what happened outside it;
+ * - non-adaptive events are irrelevant, not invalid;
+ * - every truncation / coverage limit is explicit, never silent.
+ */
+export declare const ADAPTIVE_JOURNAL_SCHEMA_VERSION: 'pd-aa-journal-reconciliation/v1';
+export declare const ADAPTIVE_JOURNAL_CANDIDATE_DIRS: readonly ['.pd/logs', '.state/logs'];
+export declare const ADAPTIVE_JOURNAL_MAX_DATE_FILES_PER_DIR = 9;
+export declare const ADAPTIVE_JOURNAL_MAX_FILE_BYTES: number;
+export declare const ADAPTIVE_JOURNAL_MAX_INVOCATIONS = 1000;
+export declare const ADAPTIVE_JOURNAL_MAX_TERMINAL_VARIANTS = 5;
+export declare const ADAPTIVE_JOURNAL_SUPPORTED_HOST = "openclaw";
+export type JournalClassification = 'paired_open_and_terminal' | 'open_only' | 'terminal_only' | 'conflicted' | 'invalid';
+/** Closed reason-code set from design §6. */
+export type JournalReasonCode = 'terminal_not_visible_in_range' | 'window_end_explicit_not_now' | 'start_not_visible_in_range' | 'exact_duplicate_record' | 'multiple_starts_conflict' | 'conflicting_terminal_states' | 'target_identity_mismatch' | 'malformed_json' | 'non_adaptive_event' | 'invalid_envelope' | 'missing_hook_invocation_id' | 'invalid_four_dimension_state' | 'session_identity_mismatch' | 'workspace_identity_unknown' | 'foreign_workspace' | 'host_identity_unknown' | 'record_before_coverage_start' | 'output_truncated' | 'terminal_variants_truncated';
+export type JournalSessionIdSource = 'envelope' | 'data' | 'both' | 'none';
+export type JournalCoverageStatus = 'complete' | 'partial' | 'unavailable';
+export type JournalCountBasis = 'exact' | 'lower_bound' | null;
+export interface AdaptiveJournalRequestWindow {
+    start: string;
+    end: string;
+    inclusiveBounds: '[start,end]';
+    endIsNow: boolean;
+    requestedStart: string;
+    clampedByRetention: boolean;
+    retentionDays: number;
+}
+export interface AdaptiveJournalRequest {
+    workspaceDir: string;
+    host: string;
+    window: AdaptiveJournalRequestWindow;
+    logDirs: string[];
+    pairingKey: string[];
+}
+export interface AdaptiveJournalCoverageError {
+    logDir: string;
+    file: string | null;
+    code: 'read_failed' | 'stat_failed' | 'outside_workspace';
+    message: string;
+}
+export interface AdaptiveJournalCoverage {
+    status: JournalCoverageStatus;
+    sourceDirsFound: number;
+    filesRead: number;
+    filesSkipped: number;
+    bytesRead: number;
+    dateFilesIntersecting: number;
+    limitCode: 'coverage_file_limit_reached' | null;
+    filesOmitted: string[];
+    truncatedFiles: string[];
+    errors: AdaptiveJournalCoverageError[];
+    /**
+     * True when at least one record's canonical full content exceeded the identity
+     * comparison budget. Those records were conservatively treated as distinct:
+     * exact duplication was never asserted for them.
+     */
+    identityComparisonLimited: boolean;
+}
+export interface AdaptiveJournalTotals {
+    linesRead: number | null;
+    adaptiveRecords: number | null;
+    nonAdaptiveLines: number | null;
+    malformedJsonLines: number | null;
+    invalidEnvelopeRecords: number | null;
+    invalidRecords: number | null;
+    duplicatesExact: number | null;
+    uniqueInvocations: number | null;
+    rejectedRecords: number | null;
+    countsAreLowerBounds: boolean;
+}
+export interface AdaptiveJournalRecordProjection {
+    ts: string;
+    receiptState: 'open' | 'closed' | 'reconciled';
+    execution: string;
+    payload: string;
+    selection: string;
+    submission: string;
+    selectionPending: boolean | null;
+    reason: string | null;
+    artifactId: string | null;
+    activationId: string | null;
+    requestId: string | null;
+    evidenceReferencePresent: boolean;
+    /** Transcribed as recorded; never re-verified by this reader. */
+    evidenceIndependentlyVerifiedAsRecorded: boolean | null;
+    /** Transcribed as recorded; never re-verified by this reader. */
+    hostKillConfirmedAsRecorded: boolean | null;
+}
+export interface AdaptiveJournalInvocationIdentity {
+    host: string;
+    workspaceDir: string | null;
+    workspaceVerified: boolean;
+    sessionId: string | null;
+    sessionIdSource: JournalSessionIdSource;
+    runId: string | null;
+}
+export interface AdaptiveJournalInvocation {
+    invocationId: string;
+    identity: AdaptiveJournalInvocationIdentity;
+    targetConsistent: boolean | null;
+    classification: JournalClassification;
+    reasonCodes: JournalReasonCode[];
+    open: AdaptiveJournalRecordProjection | null;
+    terminal: AdaptiveJournalRecordProjection | null;
+    terminalVariants: AdaptiveJournalRecordProjection[];
+    terminalVariantsOmitted: number;
+    duplicates: {
+        open: number;
+        terminal: number;
+    };
+    window: {
+        openInWindow: boolean;
+        terminalInWindow: boolean;
+        terminalSearchComplete: boolean;
+    };
+    unknowns: string[];
+}
+export interface AdaptiveJournalRejectedGroup {
+    reasonCode: JournalReasonCode;
+    count: number;
+    samples: {
+        logDir: string;
+        file: string;
+        line: number;
+        hookInvocationId: string | null;
+    }[];
+}
+export interface AdaptiveJournalAnswer {
+    count: number | null;
+    countBasis: JournalCountBasis;
+    invocationIds: string[];
+    reasonCodes?: string[];
+}
+export interface AdaptiveJournalTruncation {
+    reason: 'output_truncated';
+    limit: number;
+    included: number;
+    omitted: number;
+    omittedByClassification: Record<JournalClassification, number>;
+    variantLimitPerInvocation: number;
+    terminalVariantsOmitted: number;
+    coverageLimitCode: 'coverage_file_limit_reached' | null;
+    suggestions: string[];
+}
+export interface AdaptiveJournalReport {
+    schemaVersion: typeof ADAPTIVE_JOURNAL_SCHEMA_VERSION;
+    generatedAt: string;
+    readOnly: true;
+    request: AdaptiveJournalRequest;
+    coverage: AdaptiveJournalCoverage;
+    totals: AdaptiveJournalTotals;
+    invocations: AdaptiveJournalInvocation[];
+    rejected: AdaptiveJournalRejectedGroup[];
+    outputTruncated: boolean;
+    truncation: AdaptiveJournalTruncation | null;
+    answers: {
+        q1_open_and_terminal: AdaptiveJournalAnswer;
+        q2_open_without_visible_terminal: AdaptiveJournalAnswer;
+        q3_missing_start_or_identity_or_invalid: AdaptiveJournalAnswer;
+        q4_duplicate_or_conflicted: AdaptiveJournalAnswer;
+        q5: {
+            confirmedFacts: string[];
+            unknowns: string[];
+            notes: string[];
+        };
+    };
+    nextAction: string[];
+}
+export interface AdaptiveJournalError {
+    code: 'invalid_since' | 'invalid_until' | 'until_after_now' | 'since_after_until' | 'invalid_limit' | 'unsupported_host';
+    message: string;
+    nextAction: string;
+}
+export interface ReconcileAdaptiveJournalInput {
+    workspaceDir: string;
+    since?: string;
+    until?: string;
+    host?: string;
+    limits?: {
+        maxDateFilesPerDir?: number;
+        maxFileBytes?: number;
+        maxInvocations?: number;
+        maxTerminalVariantsPerInvocation?: number;
+    };
+    now?: Date;
+}
+export type ReconcileAdaptiveJournalResult = {
+    ok: true;
+    report: AdaptiveJournalReport;
+} | {
+    ok: false;
+    schemaVersion: typeof ADAPTIVE_JOURNAL_SCHEMA_VERSION;
+    generatedAt: string;
+    readOnly: true;
+    error: AdaptiveJournalError;
+};
+export declare function reconcileAdaptiveJournal(input: ReconcileAdaptiveJournalInput): ReconcileAdaptiveJournalResult;