create-principles-disciple 1.122.0 → 1.122.2

package/host-runtime/dist/governance-observation-store.d.ts

@@ -122,6 +122,13 @@ export type PromoteGovernanceEvidenceResult = {
     nextAction: string;
 };
 export type ObservationDatabaseFactory = (databasePath: string) => Database.Database;
+/**
+ * Shared with the sibling governance-signal-admission module (Slice B): both
+ * modules own separate governance_* tables in the same trajectory.db, and the
+ * admission/reconciliation paths read observation-owned tables (promotion
+ * tails). One open must make the whole governance schema ready.
+ */
+export declare function ensureGovernanceSchema(db: Database.Database): void;
 type Degradation = {
     ok: false;
     reason: string;

package/host-runtime/dist/governance-observation-store.js

@@ -178,6 +178,15 @@ function ensureGovernanceObservationSchema(db) {
         }
     })();
 }
+/**
+ * Shared with the sibling governance-signal-admission module (Slice B): both
+ * modules own separate governance_* tables in the same trajectory.db, and the
+ * admission/reconciliation paths read observation-owned tables (promotion
+ * tails). One open must make the whole governance schema ready.
+ */
+export function ensureGovernanceSchema(db) {
+    ensureGovernanceObservationSchema(db);
+}
 function openStore(workspaceDir, factory) {
     const dbPath = path.join(workspaceDir, '.state', 'trajectory.db');
     if (!fs.existsSync(dbPath)) {

package/host-runtime/dist/governance-signal-admission.d.ts

@@ -0,0 +1,228 @@
+import { type SignalCollectorOutput, type UnifiedKeywordStore } from '@principles/core/runtime-v2';
+import { type ObservationDatabaseFactory } from './governance-observation-store.js';
+export declare const GOVERNANCE_STRONG_PAIN_SCORE = 70;
+export declare const GOVERNANCE_STRONG_RATE_LIMIT_PER_HOUR = 5;
+export declare const GOVERNANCE_RATE_LIMIT_WINDOW_MS: number;
+type Degradation = {
+    ok: false;
+    reason: string;
+    nextAction: string;
+};
+/** learned 词进入高精度 deterministic path 的权重阈值(仅 seed/owner_promoted; llm_learned 恒 ambiguous) */
+export declare const HIGH_PRECISION_LEARNED_WEIGHT = 0.7;
+/** 高精度纠正短语 overlay(已验证的确定性 STRONG 路径,不属于 learner seed 集) */
+export declare const HIGH_PRECISION_CORRECTION_OVERLAY: readonly (readonly [string, number])[];
+/** empathy seed overlay(检测行为不变) */
+export declare const EMPATHY_SEED_OVERLAY: readonly (readonly [string, number])[];
+export declare function buildSharedSeedKeywordStore(): UnifiedKeywordStore;
+export interface SharedCorrectionKeywordStore {
+    resolve(): UnifiedKeywordStore;
+    stats(): {
+        totalTerms: number;
+        learnedTerms: number;
+        lastReloadedAt: string | null;
+    };
+}
+export interface SharedKeywordStoreOptions {
+    readonly workspaceDir: string;
+    /** Bounded degradation sink (rc-9); defaults to silent-with-stats. */
+    readonly onDegradation?: (code: string, message: string) => void;
+    readonly logger?: {
+        debug?: (msg: string) => void;
+    };
+}
+/**
+ * Host-neutral live keyword store (extracted from the OpenClaw-only wrapper,
+ * SPEC §12): reads the per-workspace `<workspace>/.state/correction_keywords.json`
+ * learner projection with mtime-based refresh, falling back to the seed store.
+ * OpenClaw and Codex resolve detection through this SAME store. The store file
+ * must stay a direct child of the workspace state directory (boundary guard).
+ */
+export declare function createSharedCorrectionKeywordStore(options: SharedKeywordStoreOptions): SharedCorrectionKeywordStore;
+export interface CorrectionDetectionResult {
+    readonly output: SignalCollectorOutput;
+    readonly ruleVersion: number;
+}
+/**
+ * The shared synchronous high-precision correction detection (SPEC §12):
+ * one keyword store, one rule version, one STRONG classification for both
+ * hosts. Codex consumes only the deterministic high-precision path — ambiguous
+ * candidates are not signals in a bounded hook (LLM confirmation belongs to
+ * hosts that own an async stage).
+ */
+export declare function evaluateCorrectionSignal(input: {
+    workspaceDir: string;
+    text: string;
+    sessionId: string;
+    detectedAt: string;
+    store?: UnifiedKeywordStore;
+    onDegradation?: (code: string, message: string) => void;
+}): CorrectionDetectionResult;
+export type GovernanceSignalKind = 'user_correction' | 'tool_failure';
+export interface GovernanceCorrectionCandidate {
+    readonly kind: 'user_correction';
+    readonly hostKind: 'codex';
+    readonly logicalObservationKey: string;
+    readonly rolloutIdentity: string;
+    readonly rootSessionId: string;
+    readonly hostTurnId: string;
+    readonly text: string;
+    readonly observedAt: string;
+}
+export interface GovernanceToolFailureCandidate {
+    readonly kind: 'tool_failure';
+    readonly hostKind: 'codex';
+    readonly logicalObservationKey: string;
+    readonly rolloutIdentity: string;
+    readonly rootSessionId: string;
+    readonly hostTurnId: string;
+    readonly toolName: string;
+    /** Host event source (e.g. `codex:post_tool_use`) — identity parity with the live handler. */
+    readonly source: string;
+    readonly toolInput?: unknown;
+    readonly toolOutput?: unknown;
+    readonly observedAt: string;
+}
+export type GovernanceSignalCandidate = GovernanceCorrectionCandidate | GovernanceToolFailureCandidate;
+export type GovernanceAdmissionOutcome = {
+    disposition: 'admitted';
+    kind: GovernanceSignalKind;
+    logicalObservationKey: string;
+    canonicalPainId: string;
+    duplicate: boolean;
+    ruleVersion: number | null;
+} | {
+    disposition: 'already_admitted';
+    kind: GovernanceSignalKind;
+    logicalObservationKey: string;
+    canonicalPainId: string;
+    diagnosticianTaskId: string | null;
+} | {
+    disposition: 'not_a_signal';
+    kind: 'user_correction';
+    logicalObservationKey: string;
+} | {
+    disposition: 'not_admitted';
+    kind: 'tool_failure';
+    logicalObservationKey: string;
+    reason: string;
+} | {
+    disposition: 'rate_limited';
+    kind: 'user_correction';
+    logicalObservationKey: string;
+} | Degradation;
+export interface AdmitGovernanceSignalsInput {
+    readonly workspaceDir: string;
+    readonly candidates: readonly GovernanceSignalCandidate[];
+    readonly now?: Date;
+    readonly databaseFactory?: ObservationDatabaseFactory;
+    readonly keywordStore?: UnifiedKeywordStore;
+    readonly onDegradation?: (code: string, message: string) => void;
+}
+export type AdmitGovernanceSignalsResult = {
+    ok: true;
+    outcomes: readonly GovernanceAdmissionOutcome[];
+} | Degradation;
+/**
+ * Admit governance signal candidates. Each candidate commits in its own
+ * trajectory.db transaction (marker + pain row + quota together), so one
+ * failing candidate never rolls back another's admission.
+ */
+export declare function admitGovernanceSignals(input: AdmitGovernanceSignalsInput): AdmitGovernanceSignalsResult;
+export interface EnsureGovernanceTaskInput {
+    readonly workspaceDir: string;
+    readonly logicalObservationKey: string;
+    readonly canonicalPainId: string;
+    readonly databaseFactory?: ObservationDatabaseFactory;
+}
+export type EnsureGovernanceTaskResult = {
+    ok: true;
+    taskId: string;
+    created: boolean;
+    duplicate: boolean;
+    linkRepaired: boolean;
+} | Degradation;
+/**
+ * Ensure exactly one pending Diagnostician task exists for an admitted
+ * canonical pain (SPEC §13). Idempotent across hook retries, reconciliation,
+ * and crash restarts: deterministic task id + task-store PK + marker link.
+ * Never awaits an LLM — PainToPrincipleService async mode only enqueues.
+ *
+ * `linkRepaired` is true ONLY when this call actually wrote the marker task
+ * link because the task already existed (Case B recovery). A marker that
+ * already carried the link reports linkRepaired=false — no fake repair.
+ */
+export declare function ensureGovernanceDiagnosticianTask(input: EnsureGovernanceTaskInput): Promise<EnsureGovernanceTaskResult>;
+export type PromoteAdmittedEvidenceResult = {
+    ok: true;
+    promoted: number;
+    tailState: 'completed' | 'pending';
+} | Degradation;
+/**
+ * Promote the bounded evidence window (≤12 preceding turns + trigger + next
+ * completed assistant turn) for an admitted pain, using Slice A's promotion
+ * substrate with the canonical pain id as the caller-provided pain reference.
+ */
+export declare function promoteAdmittedGovernanceEvidence(input: {
+    workspaceDir: string;
+    rolloutIdentity: string;
+    triggerLogicalKey: string;
+    canonicalPainId: string;
+    databaseFactory?: ObservationDatabaseFactory;
+}): PromoteAdmittedEvidenceResult;
+export interface EnsureGovernanceContinuationInput {
+    readonly workspaceDir: string;
+    readonly logicalObservationKey: string;
+    readonly canonicalPainId: string;
+    readonly databaseFactory?: ObservationDatabaseFactory;
+}
+export type EnsureGovernanceContinuationResult = {
+    ok: true;
+    taskId: string;
+    taskCreated: boolean;
+    linkRepaired: boolean;
+    promoted: number;
+    tailState: 'completed' | 'pending';
+} | {
+    ok: false;
+    reason: string;
+    nextAction: string;
+};
+/**
+ * Given an admitted canonical pain (identified by its marker), ensure both
+ * the Diagnostician task AND the evidence promotion exist idempotently.
+ * Single ensure path for both fresh admits and crash recovery (already_admitted
+ * redelivery). The marker row carries rollout_identity so the function is
+ * self-contained (caller only needs workspaceDir, logicalObservationKey, painId).
+ */
+export declare function ensureGovernanceContinuation(input: EnsureGovernanceContinuationInput): Promise<EnsureGovernanceContinuationResult>;
+export interface ReconcileGovernanceContinuationInput {
+    readonly workspaceDir: string;
+    /** Bounded work per pass (default 50 admitted pains). */
+    readonly limit?: number;
+    readonly databaseFactory?: ObservationDatabaseFactory;
+}
+export interface ReconcileGovernanceContinuationResult {
+    readonly ok: boolean;
+    readonly reason?: string;
+    readonly nextAction?: string;
+    readonly tasksEnsured: number;
+    readonly linksRepaired: number;
+    readonly pendingTails: number;
+    readonly completedTails: number;
+    readonly staleTails: number;
+    readonly degradations: readonly string[];
+}
+/**
+ * Narrow idempotent reconciliation between the trajectory admission markers
+ * and the Runtime V2 task store (separate SQLite databases — no cross-store
+ * transaction exists, SPEC §13). Recovers:
+ *  - Case A: pain admitted, crash before task creation → create the task now;
+ *  - Case B: task exists, crash before the link write → repair the link;
+ *  - Case C: pain+task, crash before promotion → promote evidence now;
+ *  - Case D: promotion started → pending tail → retry completion once; stale
+ *    tails are reported (never silently dropped).
+ * Not a background worker — Slice C's Companion worker and the CLI call this.
+ */
+export declare function reconcileGovernanceContinuation(input: ReconcileGovernanceContinuationInput): Promise<ReconcileGovernanceContinuationResult>;
+export {};