create-principles-disciple 1.82.0 → 1.83.0

package/console/dist/server/models/ActivationsConsoleModel.js

@@ -0,0 +1,112 @@
+import { SqliteConnection, SqliteActivationStateStore, SqlitePIArtifactStore, } from '@principles/core/runtime-v2';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function isMissingTableError(err) {
+    if (!(err instanceof Error))
+        return false;
+    return err.message.includes('no such table');
+}
+export class ActivationsConsoleModel {
+    readConnection = null;
+    writeConnection = null;
+    workspaceDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    getReadConnection() {
+        if (!this.readConnection) {
+            this.readConnection = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
+        }
+        return this.readConnection;
+    }
+    getWriteConnection() {
+        if (!this.writeConnection) {
+            this.writeConnection = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: false });
+        }
+        return this.writeConnection;
+    }
+    async getActivations() {
+        const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
+        if (!fs.existsSync(stateDbPath)) {
+            return { activations: [], generatedAt: new Date().toISOString(), note: 'state.db not found — workspace may not be initialized' };
+        }
+        const conn = this.getReadConnection();
+        const activationStore = new SqliteActivationStateStore(conn);
+        const artifactStore = new SqlitePIArtifactStore(conn);
+        let allActivations;
+        try {
+            allActivations = await activationStore.listAllActivations();
+        }
+        catch (err) {
+            if (isMissingTableError(err)) {
+                return { activations: [], generatedAt: new Date().toISOString(), note: 'activation table not found — workspace may not be initialized' };
+            }
+            throw err;
+        }
+        // Build artifactId → sourcePrincipleId map from PIArtifactSnapshot
+        const artifactPrincipleMap = new Map();
+        for (const activation of allActivations) {
+            if (!artifactPrincipleMap.has(activation.artifactId)) {
+                try {
+                    const artifact = await artifactStore.getArtifactById(activation.artifactId);
+                    artifactPrincipleMap.set(activation.artifactId, artifact?.sourcePrincipleId ?? null);
+                }
+                catch (err) {
+                    if (isMissingTableError(err)) {
+                        artifactPrincipleMap.set(activation.artifactId, null);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+        }
+        const facts = allActivations.map((record) => ({
+            id: record.activationId,
+            artifactId: record.artifactId,
+            principleId: artifactPrincipleMap.get(record.artifactId) ?? 'unlinked',
+            channel: record.channel,
+            action: record.action,
+            targetRef: record.targetRef,
+            activatedAt: record.activatedAt,
+            status: record.deactivatedAt === null ? 'active' : 'inactive',
+        }));
+        return {
+            activations: facts,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    async deactivateActivation(activationId) {
+        const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
+        if (!fs.existsSync(stateDbPath)) {
+            return { ok: false, reason: 'state.db not found — workspace may not be initialized', nextAction: 'Ensure the workspace has been initialized with PD before disabling activations.' };
+        }
+        const conn = this.getWriteConnection();
+        const activationStore = new SqliteActivationStateStore(conn);
+        try {
+            const deactivated = await activationStore.deactivateActivation(activationId, new Date().toISOString());
+            if (!deactivated) {
+                return { ok: false, reason: `Activation '${activationId}' not found or already inactive`, nextAction: 'Refresh the activation list and verify the activation ID is correct.' };
+            }
+            return { ok: true };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return { ok: false, reason: `Failed to deactivate activation: ${message}`, nextAction: 'Check server logs for details. The activation state has not been changed.' };
+        }
+    }
+    dispose() {
+        for (const conn of [this.readConnection, this.writeConnection]) {
+            if (conn) {
+                try {
+                    conn.close();
+                }
+                catch (err) {
+                    console.warn('ActivationsConsoleModel.dispose: failed to close connection:', err instanceof Error ? err.message : String(err));
+                }
+            }
+        }
+        this.readConnection = null;
+        this.writeConnection = null;
+    }
+}

package/console/dist/server/models/ApprovalsConsoleModel.d.ts

@@ -21,6 +21,11 @@ export type ApproveWithActivationResult = {
     ok: false;
     error: 'unsupported_channel';
     channel: string;
+} | {
+    ok: false;
+    error: 'activation_failed';
+    reason: string;
+    approvalRolledBack: boolean;
 };
 export declare class ApprovalsConsoleModel {
     private readConnection;

package/console/dist/server/models/ApprovalsConsoleModel.js

@@ -8,6 +8,9 @@ function isMissingTableError(err) {
         return false;
     return err.message.includes('no such table');
 }
+function isActivationSuccess(activation) {
+    return activation.decision === 'activated' || activation.decision === 'already_activated';
+}
 function stateDbExists(workspaceDir) {
     return fs.existsSync(path.join(workspaceDir, '.pd', 'state.db'));
 }
@@ -104,6 +107,17 @@ export class ApprovalsConsoleModel {
             return { ok: false, error: 'not_found' };
         }
         const activation = await this.dispatchActivationAfterApproval(existing, decidedBy);
+        // If activation failed, roll back approval to pending so the user can retry.
+        if (activation && !isActivationSuccess(activation)) {
+            const detail = 'reason' in activation ? activation.reason : activation.decision;
+            let approvalRolledBack = false;
+            try {
+                const rollbackResult = await this.getWriteQueue().resetToPending(approvalId);
+                approvalRolledBack = rollbackResult.ok;
+            }
+            catch { /* best-effort rollback */ }
+            return { ok: false, error: 'activation_failed', reason: detail, approvalRolledBack };
+        }
         return { ok: true, record: approvalResult.record, activation };
     }
     async dispatchActivationAfterApproval(existing, decidedBy) {

package/console/dist/server/models/ApprovalsGroupedConsoleModel.d.ts

@@ -0,0 +1,25 @@
+export interface ApprovalGroup {
+    principleId: string;
+    principleTitle: string;
+    status: 'pending' | 'approved' | 'rejected';
+    records: {
+        id: string;
+        artifactId: string;
+        channel: string;
+        createdAt: string;
+    }[];
+}
+export interface ApprovalsGroupedResponse {
+    groups: ApprovalGroup[];
+    generatedAt: string;
+    /** Present when data is degraded/missing rather than genuinely empty */
+    note?: string;
+}
+export declare class ApprovalsGroupedConsoleModel {
+    private readConnection;
+    private readonly workspaceDir;
+    constructor(workspaceDir: string);
+    private getReadConnection;
+    getApprovalsGrouped(): Promise<ApprovalsGroupedResponse>;
+    dispose(): void;
+}

package/console/dist/server/models/ApprovalsGroupedConsoleModel.js

@@ -0,0 +1,126 @@
+import { SqliteConnection, SqliteApprovalQueueStore, SqlitePIArtifactStore, ApprovalQueue, loadLedger, } from '@principles/core/runtime-v2';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+function isMissingTableError(err) {
+    if (!(err instanceof Error))
+        return false;
+    return err.message.includes('no such table');
+}
+export class ApprovalsGroupedConsoleModel {
+    readConnection = null;
+    workspaceDir;
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+    }
+    getReadConnection() {
+        if (!this.readConnection) {
+            this.readConnection = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
+        }
+        return this.readConnection;
+    }
+    async getApprovalsGrouped() {
+        const stateDbPath = path.join(this.workspaceDir, '.pd', 'state.db');
+        if (!fs.existsSync(stateDbPath)) {
+            return { groups: [], generatedAt: new Date().toISOString(), note: 'state.db not found — workspace may not be initialized' };
+        }
+        const conn = this.getReadConnection();
+        const store = new SqliteApprovalQueueStore(conn);
+        const queue = new ApprovalQueue(store);
+        const artifactStore = new SqlitePIArtifactStore(conn);
+        let allApprovals;
+        try {
+            allApprovals = await queue.listAll();
+        }
+        catch (err) {
+            if (isMissingTableError(err)) {
+                return { groups: [], generatedAt: new Date().toISOString(), note: 'approval table not found — workspace may not be initialized' };
+            }
+            throw err;
+        }
+        // Build artifactId → sourcePrincipleId map
+        const artifactPrincipleMap = new Map();
+        for (const approval of allApprovals) {
+            if (!artifactPrincipleMap.has(approval.artifactId)) {
+                try {
+                    const artifact = await artifactStore.getArtifactById(approval.artifactId);
+                    artifactPrincipleMap.set(approval.artifactId, artifact?.sourcePrincipleId ?? null);
+                }
+                catch (err) {
+                    if (isMissingTableError(err)) {
+                        artifactPrincipleMap.set(approval.artifactId, null);
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+            }
+        }
+        // Load ledger for principle titles
+        const stateDir = path.join(this.workspaceDir, '.state');
+        let principleTitles = new Map();
+        try {
+            const ledger = loadLedger(stateDir);
+            for (const [id, principle] of Object.entries(ledger.tree.principles)) {
+                principleTitles.set(id, principle.text);
+            }
+        }
+        catch {
+            // Ledger not available — will fall back to principleId
+        }
+        // Group by principleId (null → "unlinked")
+        const groupMap = new Map();
+        for (const approval of allApprovals) {
+            const principleId = artifactPrincipleMap.get(approval.artifactId) ?? 'unlinked';
+            if (!groupMap.has(principleId)) {
+                groupMap.set(principleId, []);
+            }
+            const records = groupMap.get(principleId);
+            if (!records)
+                continue;
+            records.push({
+                id: approval.approvalId,
+                artifactId: approval.artifactId,
+                channel: approval.channel,
+                createdAt: approval.requestedAt,
+                status: approval.status,
+            });
+        }
+        const groups = [];
+        for (const [principleId, records] of groupMap) {
+            // Determine overall group status
+            const statuses = records.map((r) => r.status);
+            let status;
+            if (statuses.every((s) => s === 'approved')) {
+                status = 'approved';
+            }
+            else if (statuses.every((s) => s === 'rejected')) {
+                status = 'rejected';
+            }
+            else {
+                status = 'pending';
+            }
+            const principleTitle = principleTitles.get(principleId) ?? principleId;
+            groups.push({
+                principleId,
+                principleTitle,
+                status,
+                records,
+            });
+        }
+        return {
+            groups,
+            generatedAt: new Date().toISOString(),
+        };
+    }
+    dispose() {
+        if (this.readConnection) {
+            try {
+                this.readConnection.close();
+            }
+            catch (err) {
+                console.warn('ApprovalsGroupedConsoleModel.dispose: failed to close connection:', err instanceof Error ? err.message : String(err));
+            }
+            this.readConnection = null;
+        }
+    }
+}

package/console/dist/server/models/ConsoleLifecycleDatasource.d.ts

@@ -0,0 +1,13 @@
+import type { LifecycleDatasource } from '@principles/core/runtime-v2';
+import type { LedgerTreeStore, ReplayReport, ArtifactLineageRecord } from '@principles/core/runtime-v2';
+export declare class LineageSourceRetiredError extends Error {
+    constructor();
+}
+export declare class ConsoleLifecycleDatasource implements LifecycleDatasource {
+    private readonly workspaceDir;
+    private readonly stateDir;
+    constructor(workspaceDir: string, stateDir: string);
+    loadLedger(): LedgerTreeStore;
+    listReplayReports(implementationId: string): ReplayReport[];
+    listLineageRecords(_kind: 'behavioral-sample' | 'rule-implementation-candidate'): ArtifactLineageRecord[];
+}

package/console/dist/server/models/ConsoleLifecycleDatasource.js

@@ -0,0 +1,73 @@
+import { loadLedger } from '@principles/core/runtime-v2';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+export class LineageSourceRetiredError extends Error {
+    constructor() {
+        super('Artifact lineage source retired in PRI-230. ' +
+            'The nocturnal-artifact-lineage module has been deleted; ' +
+            'this datasource cannot provide lineage records. ' +
+            'Callers must handle this error explicitly rather than interpreting an empty result as "no lineage".');
+        this.name = 'LineageSourceRetiredError';
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function validateReplayReport(raw) {
+    if (!isRecord(raw))
+        return null;
+    if (typeof raw.implementationId !== 'string')
+        return null;
+    if (typeof raw.overallDecision !== 'string')
+        return null;
+    if (typeof raw.generatedAt !== 'string')
+        return null;
+    // After basic structural checks, cast through unknown for ReplayReport
+    // This is acceptable: the file comes from PD's own replay-reports directory,
+    // and we've validated the key discriminator fields above.
+    return raw;
+}
+export class ConsoleLifecycleDatasource {
+    workspaceDir;
+    stateDir;
+    constructor(workspaceDir, stateDir) {
+        this.workspaceDir = workspaceDir;
+        this.stateDir = stateDir;
+    }
+    loadLedger() {
+        const { tree } = loadLedger(this.stateDir);
+        // Runtime shape check: tree must be a non-null object with 'principles' record
+        if (typeof tree !== 'object' || tree === null || !isRecord(tree.principles)) {
+            throw new Error(`ConsoleLifecycleDatasource.loadLedger: ledger tree is malformed. ` +
+                `Expected object with 'principles' record, got ${tree === null ? 'null' : typeof tree}. ` +
+                `stateDir=${this.stateDir}`);
+        }
+        return tree;
+    }
+    listReplayReports(implementationId) {
+        const reportDir = path.join(this.stateDir, 'principles', 'implementations', implementationId, 'replays');
+        if (!fs.existsSync(reportDir))
+            return [];
+        try {
+            const files = fs.readdirSync(reportDir).filter((file) => file.endsWith('.json'));
+            return files
+                .sort()
+                .reverse()
+                .map((file) => {
+                const content = fs.readFileSync(path.join(reportDir, file), 'utf-8');
+                const parsed = JSON.parse(content);
+                return validateReplayReport(parsed);
+            })
+                .filter((report) => report !== null);
+        }
+        catch (err) {
+            console.warn(`ConsoleLifecycleDatasource.listReplayReports: failed to read replay reports ` +
+                `for implementationId=${implementationId}: ${err instanceof Error ? err.message : String(err)}`);
+            return [];
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
+    listLineageRecords(_kind) {
+        throw new LineageSourceRetiredError();
+    }
+}

package/console/dist/server/models/EvidenceChainConsoleModel.d.ts

@@ -0,0 +1,58 @@
+/**
+ * EvidenceChainConsoleModel — read model for the Behavior Evidence page.
+ *
+ * Reads real pain/evidence/diagnosis chain data from:
+ * - pain_events table in trajectory.db
+ * - tasks table in state.db (diagnostician tasks)
+ * - principle_candidates table in state.db
+ * - principle ledger JSON
+ *
+ * Returns structured EvidenceChainRecord items that the frontend can
+ * render as single-record cards with proper state grouping.
+ *
+ * Privacy boundary (G.2 / F.3 / F.5):
+ * - No raw prompt, chat, trajectory, token, full absolute path, or stack trace
+ * - All summaries go through sanitizeString from evidence-sanitizer
+ * - Degraded paths include structured reason + nextAction (ERR-002)
+ *
+ * ERR checklist:
+ * - ERR-001/005: All DB rows treated as unknown, runtime validation with typeof guards
+ * - ERR-002: Degraded paths include reason + nextAction, never silent fallback
+ * - ERR-009/010: Required fields fail loud
+ * - ERR-014/016/017: Evidence previews bounded via sanitizeString
+ * - ERR-013: Use Object.hasOwn() for untrusted object keys
+ */
+export type EvidenceChainState = 'evidence_only' | 'pain_recorded' | 'diagnosis_queued' | 'diagnosis_running' | 'diagnosis_succeeded' | 'diagnosis_failed' | 'diagnosis_retry_wait' | 'candidate_generated' | 'internalization_started';
+export interface EvidenceChainRecord {
+    id: string;
+    sourceKind: string;
+    observedAt: string;
+    state: EvidenceChainState;
+    summary: string;
+    admissionDecision?: string;
+    linkedPainId?: string;
+    linkedTaskId?: string;
+    linkedTaskStatus?: string;
+    linkedCandidateId?: string;
+    linkedPrincipleId?: string;
+    failureReason?: string;
+    degradedReason?: string;
+    nextAction?: string;
+}
+export interface EvidenceChainResponse {
+    records: EvidenceChainRecord[];
+    generatedAt: string;
+    /** Present when data sources are degraded rather than genuinely empty */
+    degradedReason?: string;
+    nextAction?: string;
+    /** Present when evidence-only sources exist but no pain signals */
+    note?: string;
+}
+export declare class EvidenceChainConsoleModel {
+    private readConnection;
+    private readonly workspaceDir;
+    constructor(workspaceDir: string);
+    private getReadConnection;
+    getEvidenceChain(): Promise<EvidenceChainResponse>;
+    dispose(): void;
+}