@principles/host-runtime 0.1.0 → 0.2.0

package/dist/internalization-consumer-governance.js

@@ -0,0 +1,152 @@
+/**
+ * Internalization consumer governance wiring (host-neutral, PRI-624).
+ *
+ * Ported verbatim from openclaw-plugin `auto-consumer-governance-wiring.ts`
+ * (P0-D/E/F 生产接线) so the OpenClaw auto-consumer and the Companion
+ * workspace worker share ONE wiring implementation instead of copying it:
+ *   - evaluator: isRepairLoopEnabled + seedArtificerRepairTask (bounded repair)
+ *   - rollout_reviewer: dispatchActivation (approve_rollout → ActivationDispatcher,
+ *     低风险 auto_activate / 高风险 approvals.pending) + reopenRevisionTarget
+ *     (needs_revision → reopen scribe/artificer, 禁止入 approval)
+ *
+ * Everything is assembled from @principles/core stores/dispatchers; the only
+ * host knowledge is a structural logger. Idempotency (INV-08): dispatcher
+ * dedupes by `${artifactId}::${channel}`; reopen idempotency is owned by
+ * orchestrator.reopenTaskForRevision.
+ */
+import { ActivationDispatcher, PromptWriter, DeferArchiveWriter, RuleHostWriter, SqliteConnection, SqliteActivationStateStore, SqliteApprovalQueueStore, SqlitePIArtifactStore, createProductionGateDeps, createPITaskDiagnosticJson, computeFeatureFlagsFromConfig, isFeatureEnabled, } from '@principles/core/runtime-v2';
+import { loadPdConfigForPlugin } from './pd-config.js';
+function normalizeDecision(decision) {
+    if (decision.decision === 'activated') {
+        return { decision: decision.decision, activationId: decision.activationId };
+    }
+    if (decision.decision === 'already_activated') {
+        return { decision: decision.decision, reason: 'idempotent_redispatch' };
+    }
+    if (decision.decision === 'queued_for_approval') {
+        return { decision: decision.decision, reason: decision.approvalId };
+    }
+    // refused / would_* 家族
+    const reason = 'reason' in decision && typeof decision.reason === 'string' ? decision.reason : decision.decision;
+    return { decision: decision.decision, reason };
+}
+function makeFlagProbe(workspaceDir) {
+    const configResult = loadPdConfigForPlugin(workspaceDir);
+    if (!configResult.ok)
+        return () => false;
+    const flags = computeFeatureFlagsFromConfig(configResult.effective);
+    return (flagId) => isFeatureEnabled(flags, flagId);
+}
+/** rollout → ActivationDispatcher 的生产接线 (per dispatch 打开短连接, 与 Console 模式一致) */
+export async function dispatchRolloutActivation(workspaceDir, input, logger) {
+    const connection = new SqliteConnection(workspaceDir);
+    try {
+        const piArtifactStore = new SqlitePIArtifactStore(connection);
+        const artifactReadModel = {
+            getArtifactById: async (id) => {
+                const rec = await piArtifactStore.getArtifactById(id);
+                if (!rec)
+                    return null;
+                return {
+                    artifactId: rec.artifactId,
+                    artifactKind: rec.artifactKind,
+                    sourceTaskId: rec.sourceTaskId,
+                    sourcePrincipleId: rec.sourcePrincipleId,
+                    sourceRuleId: rec.sourceRuleId,
+                    lineageArtifactIds: rec.lineageArtifactIds,
+                    validationStatus: rec.validationStatus,
+                    contentJson: rec.contentJson,
+                    createdAt: rec.createdAt,
+                    updatedAt: rec.updatedAt,
+                };
+            },
+        };
+        const activationStateStore = new SqliteActivationStateStore(connection);
+        const approvalQueueStore = new SqliteApprovalQueueStore(connection);
+        const flagProbe = makeFlagProbe(workspaceDir);
+        const dispatcher = new ActivationDispatcher(artifactReadModel, activationStateStore, {
+            writers: [
+                new PromptWriter(),
+                new RuleHostWriter({ gateDeps: createProductionGateDeps(), featureFlagProbe: flagProbe }),
+                new DeferArchiveWriter(),
+            ],
+            approvalQueueStore,
+        });
+        const decision = await dispatcher.dispatch({
+            artifactId: input.artifactId,
+            channel: input.channel, // InternalizationChannel union; rollout 链的 channel 已由任务元数据校验
+            rolloutDecision: 'auto_activate',
+            actor: { kind: 'system', source: 'rollout_reviewer' },
+            now: new Date().toISOString(),
+            confirm: true,
+            confidence: input.confidence,
+        });
+        const outcome = normalizeDecision(decision);
+        logger?.info?.(`[PD:Consumer] rollout dispatch: artifact=${input.artifactId} channel=${input.channel} → ${outcome.decision}${outcome.activationId ? ` (${outcome.activationId})` : ''}${outcome.reason ? ` reason=${outcome.reason}` : ''}`);
+        return outcome;
+    }
+    finally {
+        try {
+            connection.close();
+        }
+        catch { /* best-effort */ }
+    }
+}
+/** flag 探针: config 异常 → 全 false (fail-closed, 不 throw) */
+/** evaluator repair deps (PRI-509 机制的生产接线; flag 语义保留为运行时开关) */
+export function createEvaluatorRepairDeps(workspaceDir, stateManager, logger) {
+    return {
+        isRepairLoopEnabled: () => {
+            // flag evaluator_artificer_repair_loop (registry 默认已改为 ON — 见
+            // feature-flag-contract.ts;此处读取 config 以保留运行时可关闭能力)
+            const configResult = loadPdConfigForPlugin(workspaceDir);
+            if (!configResult.ok)
+                return false;
+            const flags = computeFeatureFlagsFromConfig(configResult.effective);
+            return isFeatureEnabled(flags, 'evaluator_artificer_repair_loop');
+        },
+        seedArtificerRepairTask: async (params) => {
+            // P0-4: 确定性 revision identity — evaluatorTaskId + iteration 唯一定位
+            // 一个逻辑 repair 任务; 重放 (consumer 重复周期 / crash 恢复) reuse 而非再建。
+            const repairTaskId = `artificer-repair-${params.repairPayload.sourceEvaluatorTaskId}-r${params.repairPayload.repairIteration}`;
+            const existing = await stateManager.getTask(repairTaskId);
+            if (existing) {
+                logger?.info?.(`[PD:Consumer] repair task ${repairTaskId} already exists; reusing (idempotent seed)`);
+                return repairTaskId;
+            }
+            await stateManager.createTask({
+                taskId: repairTaskId,
+                taskKind: 'artificer',
+                status: 'pending',
+                attemptCount: 0,
+                maxAttempts: 3,
+                diagnosticJson: createPITaskDiagnosticJson({
+                    dependencyTaskIds: [...params.inheritedDependencyTaskIds],
+                    channel: params.inheritedChannel,
+                    timeoutMs: params.inheritedTimeoutMs,
+                    inputArtifactRefs: [...params.inheritedInputArtifactRefs],
+                    outputArtifactRefs: [],
+                    repairPayload: params.repairPayload,
+                }),
+            });
+            logger?.info?.(`[PD:Consumer] seeded artificer repair task ${repairTaskId} (iteration ${params.repairPayload.repairIteration})`);
+            return repairTaskId;
+        },
+    };
+}
+/** rollout reviewer 治理 deps: dispatch + revision reopen */
+export function createRolloutGovernanceDeps(workspaceDir, orchestrator, logger) {
+    return {
+        dispatchActivation: (input) => dispatchRolloutActivation(workspaceDir, input, logger),
+        reopenRevisionTarget: async (input) => {
+            const result = await orchestrator.reopenTaskForRevision(input.targetTaskId, {
+                revisionFeedback: input.revisionFeedback,
+                reason: `rollout_revision_iteration_${input.revisionIteration}`,
+                revisionCauseId: `rollout-${input.sourceRolloutTaskId}-r${input.revisionIteration}`,
+            });
+            return result.ok
+                ? { ok: true, reason: result.reason, reopenedTaskId: input.targetTaskId }
+                : { ok: false, reason: result.reason };
+        },
+    };
+}

package/dist/legacy-rule-contract-symbols.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Retired RuleHost contract symbol scan — host-runtime local copy.
+ *
+ * The shared canonical scanner lives in @principles/core
+ * (internalization/legacy-rule-contract-scanner.ts) and is used by the
+ * plugin, console, installer, and pd-cli. This module deliberately does NOT
+ * import it: the published codex-adapter bundle installs host-runtime
+ * against the CURRENTLY PUBLISHED @principles/core from the npm registry,
+ * and a new runtime import would break clean installs until the next core
+ * release (see tests/published-codex-adapter-bundle.test.ts — it enforces
+ * exactly this constraint). Keep the symbol patterns in sync with the core
+ * scanner; the host-runtime tests cover the same detection behavior.
+ */
+/**
+ * Conservative scan of persisted RuleCode source for retired RuleHost
+ * contract symbols (field reads and helper calls). A hit means the rule must
+ * NOT execute against the current contract — its reads would silently
+ * resolve to undefined and change owner-approved behavior.
+ */
+export declare function scanRetiredContractSymbols(implementationCode: string): string[];

package/dist/legacy-rule-contract-symbols.js

@@ -0,0 +1,124 @@
+/**
+ * Retired RuleHost contract symbol scan — host-runtime local copy.
+ *
+ * The shared canonical scanner lives in @principles/core
+ * (internalization/legacy-rule-contract-scanner.ts) and is used by the
+ * plugin, console, installer, and pd-cli. This module deliberately does NOT
+ * import it: the published codex-adapter bundle installs host-runtime
+ * against the CURRENTLY PUBLISHED @principles/core from the npm registry,
+ * and a new runtime import would break clean installs until the next core
+ * release (see tests/published-codex-adapter-bundle.test.ts — it enforces
+ * exactly this constraint). Keep the symbol patterns in sync with the core
+ * scanner; the host-runtime tests cover the same detection behavior.
+ */
+// Helper-call form is listed before the bare-word form; the field pattern's
+// negative lookahead prevents one hasPlanFile( call reporting twice.
+const RETIRED_SYMBOL_PATTERNS = [
+    { symbol: 'recentThinking', pattern: /\brecentThinking\b/ },
+    { symbol: 'planStatus', pattern: /\bplanStatus\b/ },
+    { symbol: 'getPlanStatus', pattern: /\bgetPlanStatus\s*\(/ },
+    { symbol: 'hasPlanFileHelper', pattern: /\bhasPlanFile\s*\(/ },
+    { symbol: 'hasPlanFile', pattern: /\bhasPlanFile\b(?!\s*\()/ },
+];
+function maskNonExecutableText(source) {
+    let state = 'code';
+    let templateExpressionDepth = 0;
+    let masked = '';
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index] ?? '';
+        const next = source[index + 1] ?? '';
+        if (state === 'code') {
+            if (templateExpressionDepth > 0 && char === '{') {
+                templateExpressionDepth += 1;
+                masked += char;
+            }
+            else if (templateExpressionDepth > 0 && char === '}') {
+                templateExpressionDepth -= 1;
+                masked += char;
+                if (templateExpressionDepth === 0)
+                    state = 'template';
+            }
+            else if (char === '/' && next === '/') {
+                masked += '  ';
+                index += 1;
+                state = 'line_comment';
+            }
+            else if (char === '/' && next === '*') {
+                masked += '  ';
+                index += 1;
+                state = 'block_comment';
+            }
+            else if (char === "'") {
+                masked += ' ';
+                state = 'single_quote';
+            }
+            else if (char === '"') {
+                masked += ' ';
+                state = 'double_quote';
+            }
+            else if (char === '`') {
+                masked += ' ';
+                state = 'template';
+            }
+            else {
+                masked += char;
+            }
+            continue;
+        }
+        if (state === 'line_comment') {
+            masked += char === '\n' || char === '\r' ? char : ' ';
+            if (char === '\n' || char === '\r')
+                state = 'code';
+            continue;
+        }
+        if (state === 'block_comment') {
+            if (char === '*' && next === '/') {
+                masked += '  ';
+                index += 1;
+                state = 'code';
+            }
+            else {
+                masked += char === '\n' || char === '\r' ? char : ' ';
+            }
+            continue;
+        }
+        if (state === 'template' && char === '$' && next === '{') {
+            masked += ' {';
+            index += 1;
+            templateExpressionDepth = 1;
+            state = 'code';
+            continue;
+        }
+        if (char === '\\') {
+            masked += ' ';
+            if (index + 1 < source.length) {
+                masked += source[index + 1] === '\n' || source[index + 1] === '\r' ? source[index + 1] : ' ';
+                index += 1;
+            }
+            continue;
+        }
+        const closesLiteral = (state === 'single_quote' && char === "'") ||
+            (state === 'double_quote' && char === '"') ||
+            (state === 'template' && char === '`');
+        masked += char === '\n' || char === '\r' ? char : ' ';
+        if (closesLiteral)
+            state = 'code';
+    }
+    return masked;
+}
+/**
+ * Conservative scan of persisted RuleCode source for retired RuleHost
+ * contract symbols (field reads and helper calls). A hit means the rule must
+ * NOT execute against the current contract — its reads would silently
+ * resolve to undefined and change owner-approved behavior.
+ */
+export function scanRetiredContractSymbols(implementationCode) {
+    const executableSource = maskNonExecutableText(implementationCode);
+    const symbols = [];
+    for (const { symbol, pattern } of RETIRED_SYMBOL_PATTERNS) {
+        if (pattern.test(executableSource)) {
+            symbols.push(symbol);
+        }
+    }
+    return symbols;
+}

package/dist/product-telemetry/consent-store.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Product telemetry control-state store — Anonymous Product Telemetry v1
+ * (PRI-597, SPEC §44; review remediation: workspace-scoped export state).
+ *
+ * Persists the telemetry control state to `~/.pd/product-telemetry.json`.
+ * This file is Telemetry Control State — it never enters
+ * Principle/Pain/receipt/governance stores, and the secret never leaves the
+ * machine.
+ *
+ * Scope model (schema v2, review remediation P1-1):
+ * - MACHINE scope: consent, consentVersion, telemetrySecret.
+ * - WORKSPACE scope: `workspaceExports[scopeId]` — per-workspace dedup,
+ *   retry, and attempt bookkeeping keyed by the opaque local scope ID
+ *   (HMAC(secret, canonical workspace path); never uploaded). One
+ *   workspace succeeding must never suppress another workspace's export.
+ *
+ * Migration from schema v1: consent, consentVersion, and telemetrySecret are
+ * preserved; legacy machine-global export bookkeeping (lastSucceededAt,
+ * retry state, attempt counters) is DISCARDED — it cannot be attributed to a
+ * workspace, and it is operational state, not a governance fact. Dropping it
+ * can cause at most one extra same-day snapshot per installation.
+ */
+export declare const PRODUCT_TELEMETRY_STATE_FILENAME = "product-telemetry.json";
+export declare const PRODUCT_TELEMETRY_CONTROL_SCHEMA_VERSION = "2";
+/** v1 files are still read (then migrated in memory and rewritten as v2). */
+export declare const PRODUCT_TELEMETRY_LEGACY_CONTROL_SCHEMA_VERSION = "1";
+/** Hard bound on tracked workspaces so the file cannot grow unboundedly. */
+export declare const MAX_WORKSPACE_EXPORT_ENTRIES = 200;
+/**
+ * Entries untouched for this long are pruned on the next write. This is local
+ * telemetry operational state only — no workspace history is retained.
+ */
+export declare const WORKSPACE_EXPORT_STATE_MAX_AGE_DAYS = 30;
+export type ProductTelemetryConsent = 'unset' | 'granted' | 'denied';
+/** Per-workspace export bookkeeping (operational state; never exported). */
+export interface WorkspaceExportState {
+    lastAttemptedAt?: string;
+    lastSucceededAt?: string;
+    /** Coarse failure code (TelemetryFailureCode). No response bodies. */
+    lastFailureCode?: string;
+    nextRetryAt?: string;
+    /** Failed export attempts in the current attemptBucketDate (0–99; hard cap enforced by the service). */
+    dailyAttemptCount?: number;
+    /** UTC date bucket the dailyAttemptCount belongs to (resets on day change). */
+    attemptBucketDate?: string;
+}
+export interface ProductTelemetryControlState {
+    consent: ProductTelemetryConsent;
+    consentVersion: string;
+    /** Cryptographically random hex secret. Never uploaded. */
+    telemetrySecret?: string;
+    /** Per-workspace export bookkeeping keyed by opaque local scope ID. */
+    workspaceExports?: Record<string, WorkspaceExportState>;
+    schemaVersion: string;
+}
+export type ControlStateRead = {
+    ok: true;
+    state: ProductTelemetryControlState;
+    existed: boolean;
+} | {
+    ok: false;
+    reason: string;
+    nextAction: string;
+};
+export type ControlStateWrite = {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+    nextAction: string;
+};
+export declare function defaultProductTelemetryControlState(): ProductTelemetryControlState;
+export declare function getProductTelemetryStatePath(homeDir: string): string;
+/**
+ * Read and validate the control state. A missing file is the normal
+ * never-configured case (defaults, existed=false). A malformed file is a
+ * loud failure — silently treating it as "unset" could re-prompt or re-export
+ * against the user's recorded decision (rc-3/rc-9).
+ *
+ * v1 files are migrated in memory (export bookkeeping dropped, consent
+ * identity preserved); the migration is persisted on the next write.
+ */
+export declare function readProductTelemetryControlState(homeDir: string): ControlStateRead;
+/**
+ * Drop `workspaceExports` entries whose most recent activity (attempt or
+ * success) is older than WORKSPACE_EXPORT_STATE_MAX_AGE_DAYS. Bounded local
+ * operational state only — this is not a workspace history database.
+ */
+export declare function pruneWorkspaceExports(state: ProductTelemetryControlState, nowMs: number): ProductTelemetryControlState;
+/** Atomic write (temp file + rename) so a crash never truncates the state. */
+export declare function writeProductTelemetryControlState(homeDir: string, state: ProductTelemetryControlState): ControlStateWrite;
+/** State after `pd telemetry enable`: explicit granted consent + secret. */
+export declare function grantedControlState(previous: ProductTelemetryControlState): ProductTelemetryControlState;
+/**
+ * State after `pd telemetry disable`: consent denied and all export identity
+ * removed (SPEC §19). The explicit `denied` choice is preserved so PD never
+ * re-prompts.
+ */
+export declare function deniedControlState(): ProductTelemetryControlState;
+/**
+ * State after `pd telemetry reset` (SPEC §18): secret and export status are
+ * deleted — no future daily ID relates to previous ones. The consent choice
+ * is preserved; a fresh secret is generated only while telemetry remains
+ * enabled. Workspace bookkeeping keyed under the OLD secret's scope IDs is
+ * dropped with it (the IDs are meaningless under a new secret).
+ */
+export declare function resetControlState(previous: ProductTelemetryControlState): ProductTelemetryControlState;