create-principles-disciple 1.121.8 → 1.121.9

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

@@ -1,20 +1,19 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { Value } from '@sinclair/typebox/value';
-import { GovernanceFactsSchema, SqliteConnection, isPDErrorCategory, parsePITaskMetadata, } from '@principles/core/runtime-v2';
-const GOVERNANCE_TASK_KINDS = new Set([
+import { GovernanceFactsSchema, SqliteConnection, isPDErrorCategory, parsePITaskMetadata, PD_TASK_STATUSES, PRINCIPLE_STATUSES, isPDTaskStatus, } from '@principles/core/runtime-v2';
+export const GOVERNANCE_TASK_KINDS = new Set([
     'dreamer', 'philosopher', 'scribe', 'artificer', 'evaluator', 'rollout_reviewer',
 ]);
-const GOVERNANCE_TASK_STATUSES = new Set([
-    'pending', 'leased', 'succeeded', 'retry_wait', 'failed', 'needs_human_review',
-]);
-const PRINCIPLE_STATES = new Set(['candidate', 'active', 'archived', 'deprecated', 'probation']);
+// PRI-612: both status sets derive from the canonical core authorities.
+export const GOVERNANCE_TASK_STATUSES = new Set(PD_TASK_STATUSES);
+const PRINCIPLE_STATES = new Set(PRINCIPLE_STATUSES);
 const ISO_UTC = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
 const MAX_LINEAGE_NODES = 500;
-function isRecord(value) {
+export function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
-function readOwnString(record, key) {
+export function readOwnString(record, key) {
     if (!Object.hasOwn(record, key))
         return undefined;
     const value = record[key];
@@ -57,317 +56,356 @@ export class GovernanceProjectionCollector {
         const principle = this.readPrinciple(principleId, collectionIssues);
         const dbPath = path.join(this.workspaceDir, '.pd', 'state.db');
         if (!fs.existsSync(dbPath)) {
-            collectionIssues.push(issue({ source: 'lineage', reasonCode: 'source_unavailable', nextActionCode: 'initialize_runtime_state' }));
-            return GovernanceProjectionCollector.finish({ principleId, asOf, principle, collectionIssues });
+            return GovernanceProjectionCollector.factsForUnavailableSource({ principleId, asOf, principle, collectionIssues });
         }
-        const connection = new SqliteConnection({ workspaceDir: this.workspaceDir, readonly: true });
         try {
-            const db = connection.getDb();
-            const artifactIds = [];
-            const rootTaskIds = [];
-            const sourceRefs = [{ type: 'principle', id: principleId }];
-            const artifactRows = db.prepare(`
-        SELECT artifact_id, source_task_id, source_principle_id, lineage_artifact_ids, updated_at
-        FROM pi_artifacts ORDER BY artifact_id ASC
-      `).all();
-            const validArtifacts = new Map();
-            for (const row of artifactRows) {
-                if (!isRecord(row)) {
-                    collectionIssues.push(issue({ source: 'artifact', reasonCode: 'metadata_malformed', nextActionCode: 'repair_artifact_metadata' }));
-                    continue;
-                }
-                const artifactId = readOwnString(row, 'artifact_id');
-                const sourceTaskId = readOwnString(row, 'source_task_id');
-                const sourcePrincipleId = readOwnString(row, 'source_principle_id');
-                const updatedAt = readOwnString(row, 'updated_at');
-                const lineageJson = readOwnString(row, 'lineage_artifact_ids');
-                const lineageArtifactIds = GovernanceProjectionCollector.parseStringArrayJson(lineageJson);
-                const artifactRef = artifactId === undefined ? undefined : { type: 'artifact', id: artifactId };
-                if (artifactId === undefined || sourceTaskId === undefined || !isTimestamp(updatedAt)
-                    || lineageArtifactIds === null) {
-                    if (sourcePrincipleId === principleId) {
-                        collectionIssues.push(issue(artifactRef === undefined
-                            ? { source: 'artifact', reasonCode: 'metadata_malformed', nextActionCode: 'repair_artifact_metadata' }
-                            : { source: 'artifact', reasonCode: 'metadata_malformed', nextActionCode: 'repair_artifact_metadata', sourceRef: artifactRef }));
-                    }
-                    continue;
-                }
-                validArtifacts.set(artifactId, {
-                    artifactId, sourceTaskId, lineageArtifactIds,
-                    ...(sourcePrincipleId === undefined ? {} : { sourcePrincipleId }),
-                });
+            const tables = GovernanceProjectionCollector.readTables(this.workspaceDir);
+            return GovernanceProjectionCollector.buildFacts({ principleId, asOf, principle, tables, collectionIssues });
+        }
+        catch (error) {
+            if (error instanceof GovernanceProjectionCollectionError)
+                throw error;
+            throw new GovernanceProjectionCollectionError('governance_projection_error', 'inspect_runtime_state');
+        }
+    }
+    /** Degraded facts shape used when state.db is unavailable (shared by single + batch collectors). */
+    static factsForUnavailableSource(input) {
+        const { principleId, asOf, principle, collectionIssues } = input;
+        collectionIssues.push(issue({ source: 'lineage', reasonCode: 'source_unavailable', nextActionCode: 'initialize_runtime_state' }));
+        return GovernanceProjectionCollector.finish({ principleId, asOf, principle, collectionIssues });
+    }
+    /** Reads the four projection tables once. Closes its own connection unless one is injected (caller then owns closing). */
+    static readTables(workspaceDir, injected) {
+        const own = injected === undefined ? new SqliteConnection({ workspaceDir, readonly: true }) : null;
+        try {
+            const db = (injected ?? own)?.getDb();
+            if (db === undefined)
+                throw new Error('readTables: no database handle');
+            return {
+                artifactRows: db.prepare(`
+          SELECT artifact_id, source_task_id, source_principle_id, lineage_artifact_ids, updated_at
+          FROM pi_artifacts ORDER BY artifact_id ASC
+        `).all(),
+                taskRows: db.prepare('SELECT * FROM tasks ORDER BY task_id ASC').all(),
+                approvalRows: db.prepare('SELECT * FROM approvals ORDER BY approval_id ASC').all(),
+                activationRows: db.prepare('SELECT * FROM activations ORDER BY activated_at ASC, activation_id ASC').all(),
+            };
+        }
+        finally {
+            own?.close();
+        }
+    }
+    /** Groups pre-fetched raw rows into GovernanceFacts for ONE principle. Pure in-memory. */
+    static buildFacts(input) {
+        const { principleId, asOf, principle, tables, collectionIssues } = input;
+        const artifactIds = [];
+        const rootTaskIds = [];
+        const sourceRefs = [{ type: 'principle', id: principleId }];
+        const { artifactRows } = tables;
+        const validArtifacts = new Map();
+        for (const row of artifactRows) {
+            if (!isRecord(row)) {
+                collectionIssues.push(issue({ source: 'artifact', reasonCode: 'metadata_malformed', nextActionCode: 'repair_artifact_metadata' }));
+                continue;
             }
-            const strongArtifactIds = new Set([...validArtifacts.values()].filter(row => row.sourcePrincipleId === principleId).map(row => row.artifactId));
-            let addedArtifact = true;
-            while (addedArtifact) {
-                addedArtifact = false;
-                for (const row of validArtifacts.values()) {
-                    if (!strongArtifactIds.has(row.artifactId) && row.lineageArtifactIds.some(id => strongArtifactIds.has(id))) {
-                        strongArtifactIds.add(row.artifactId);
-                        addedArtifact = true;
-                    }
+            const artifactId = readOwnString(row, 'artifact_id');
+            const sourceTaskId = readOwnString(row, 'source_task_id');
+            const sourcePrincipleId = readOwnString(row, 'source_principle_id');
+            const updatedAt = readOwnString(row, 'updated_at');
+            const lineageJson = readOwnString(row, 'lineage_artifact_ids');
+            const lineageArtifactIds = GovernanceProjectionCollector.parseStringArrayJson(lineageJson);
+            const artifactRef = artifactId === undefined ? undefined : { type: 'artifact', id: artifactId };
+            if (artifactId === undefined || sourceTaskId === undefined || !isTimestamp(updatedAt)
+                || lineageArtifactIds === null) {
+                if (sourcePrincipleId === principleId) {
+                    collectionIssues.push(issue(artifactRef === undefined
+                        ? { source: 'artifact', reasonCode: 'metadata_malformed', nextActionCode: 'repair_artifact_metadata' }
+                        : { source: 'artifact', reasonCode: 'metadata_malformed', nextActionCode: 'repair_artifact_metadata', sourceRef: artifactRef }));
                 }
+                continue;
             }
-            for (const artifactId of [...strongArtifactIds].sort()) {
-                const artifact = validArtifacts.get(artifactId);
-                if (artifact === undefined)
-                    continue;
-                artifactIds.push(artifactId);
-                rootTaskIds.push(artifact.sourceTaskId);
-                sourceRefs.push({ type: 'artifact', id: artifactId });
-            }
-            if (artifactIds.length === 0) {
-                collectionIssues.push(issue({ source: 'lineage', reasonCode: 'lineage_not_available', nextActionCode: 'wait_for_durable_lineage' }));
-                return GovernanceProjectionCollector.finish({ principleId, asOf, principle, collectionIssues });
+            validArtifacts.set(artifactId, {
+                artifactId, sourceTaskId, lineageArtifactIds,
+                ...(sourcePrincipleId === undefined ? {} : { sourcePrincipleId }),
+            });
+        }
+        const strongArtifactIds = new Set([...validArtifacts.values()].filter(row => row.sourcePrincipleId === principleId).map(row => row.artifactId));
+        let addedArtifact = true;
+        while (addedArtifact) {
+            addedArtifact = false;
+            for (const row of validArtifacts.values()) {
+                if (!strongArtifactIds.has(row.artifactId) && row.lineageArtifactIds.some(id => strongArtifactIds.has(id))) {
+                    strongArtifactIds.add(row.artifactId);
+                    addedArtifact = true;
+                }
             }
-            const validTasks = new Map();
-            const taskRowIssues = [];
-            const taskRows = db.prepare('SELECT * FROM tasks ORDER BY task_id ASC').all();
-            for (const row of taskRows) {
-                const parsed = GovernanceProjectionCollector.parseTaskRow(row, taskRowIssues);
-                if (parsed !== null)
-                    validTasks.set(parsed.taskId, parsed);
+        }
+        for (const artifactId of [...strongArtifactIds].sort()) {
+            const artifact = validArtifacts.get(artifactId);
+            if (artifact === undefined)
+                continue;
+            artifactIds.push(artifactId);
+            rootTaskIds.push(artifact.sourceTaskId);
+            sourceRefs.push({ type: 'artifact', id: artifactId });
+        }
+        if (artifactIds.length === 0) {
+            collectionIssues.push(issue({ source: 'lineage', reasonCode: 'lineage_not_available', nextActionCode: 'wait_for_durable_lineage' }));
+            return GovernanceProjectionCollector.finish({ principleId, asOf, principle, collectionIssues });
+        }
+        const validTasks = new Map();
+        const taskRowIssues = [];
+        const { taskRows } = tables;
+        for (const row of taskRows) {
+            const parsed = GovernanceProjectionCollector.parseTaskRow(row, taskRowIssues);
+            if (parsed !== null)
+                validTasks.set(parsed.taskId, parsed);
+        }
+        const connected = GovernanceProjectionCollector.connectedTaskIds(rootTaskIds, validTasks, collectionIssues);
+        const taskLineageConfidence = collectionIssues.some(item => item.reasonCode === 'lineage_cycle' || item.reasonCode === 'lineage_limit_exceeded') ? 'weak' : 'strong';
+        for (const taskIssue of taskRowIssues) {
+            if (taskIssue.sourceRef?.type === 'task' && connected.has(taskIssue.sourceRef.id)) {
+                collectionIssues.push(taskIssue);
             }
-            const connected = GovernanceProjectionCollector.connectedTaskIds(rootTaskIds, validTasks, collectionIssues);
-            const taskLineageConfidence = collectionIssues.some(item => item.reasonCode === 'lineage_cycle' || item.reasonCode === 'lineage_limit_exceeded') ? 'weak' : 'strong';
-            for (const taskIssue of taskRowIssues) {
-                if (taskIssue.sourceRef?.type === 'task' && connected.has(taskIssue.sourceRef.id)) {
-                    collectionIssues.push(taskIssue);
-                }
+        }
+        const tasks = [];
+        const runnerVerdicts = [];
+        const derivedRelations = [];
+        const revisionIdentities = [];
+        const timelineEvents = [];
+        const materializedRevisionSources = new Set();
+        for (const taskId of connected) {
+            const task = validTasks.get(taskId);
+            if (task === undefined) {
+                collectionIssues.push(issue({ source: 'task', reasonCode: 'metadata_malformed', nextActionCode: 'repair_task_metadata', sourceRef: { type: 'task', id: taskId } }));
+                continue;
             }
-            const tasks = [];
-            const runnerVerdicts = [];
-            const derivedRelations = [];
-            const revisionIdentities = [];
-            const timelineEvents = [];
-            const materializedRevisionSources = new Set();
-            for (const taskId of connected) {
-                const task = validTasks.get(taskId);
-                if (task === undefined) {
-                    collectionIssues.push(issue({ source: 'task', reasonCode: 'metadata_malformed', nextActionCode: 'repair_task_metadata', sourceRef: { type: 'task', id: taskId } }));
+            if (task.revisionIdentity !== undefined) {
+                const identity = task.revisionIdentity;
+                const sourceTaskId = identity.kind === 'evaluator_repair'
+                    ? identity.sourceEvaluatorTaskId
+                    : identity.kind === 'rollout_reopen' ? identity.sourceRolloutTaskId : undefined;
+                const sourceArtifactId = identity.kind === 'evaluator_repair'
+                    ? identity.sourceArtificerArtifactId
+                    : identity.kind === 'rollout_reopen' ? identity.sourceArtifactId : undefined;
+                if (sourceTaskId === undefined || sourceArtifactId === undefined
+                    || !connected.has(sourceTaskId) || !strongArtifactIds.has(sourceArtifactId)) {
+                    collectionIssues.push(issue({
+                        source: 'lineage', reasonCode: 'lineage_conflict', nextActionCode: 'repair_revision_lineage',
+                        sourceRef: { type: 'task', id: task.taskId },
+                    }));
                     continue;
                 }
-                if (task.revisionIdentity !== undefined) {
-                    const identity = task.revisionIdentity;
-                    const sourceTaskId = identity.kind === 'evaluator_repair'
-                        ? identity.sourceEvaluatorTaskId
-                        : identity.kind === 'rollout_reopen' ? identity.sourceRolloutTaskId : undefined;
-                    const sourceArtifactId = identity.kind === 'evaluator_repair'
-                        ? identity.sourceArtificerArtifactId
-                        : identity.kind === 'rollout_reopen' ? identity.sourceArtifactId : undefined;
-                    if (sourceTaskId === undefined || sourceArtifactId === undefined
-                        || !connected.has(sourceTaskId) || !strongArtifactIds.has(sourceArtifactId)) {
-                        collectionIssues.push(issue({
-                            source: 'lineage', reasonCode: 'lineage_conflict', nextActionCode: 'repair_revision_lineage',
-                            sourceRef: { type: 'task', id: task.taskId },
-                        }));
-                        continue;
-                    }
-                    revisionIdentities.push(identity);
-                    materializedRevisionSources.add(sourceTaskId);
-                    derivedRelations.push({
-                        schemaVersion: '1', family: 'derived_relation', sourceRef: { type: 'task', id: task.taskId }, principleId,
-                        taskId: task.taskId, lineageConfidence: taskLineageConfidence, recordedAt: task.updatedAt,
-                        revisionIdentity: identity, relation: 'revision_materialized',
-                        evidenceRefs: [
-                            { type: 'task', id: sourceTaskId },
-                            { type: 'artifact', id: sourceArtifactId },
-                            { type: 'task', id: task.taskId },
-                        ],
-                    });
-                    timelineEvents.push({
-                        code: 'revision_reopened', occurredAt: task.createdAt, recordedAt: task.updatedAt,
-                        summaryCode: 'governance.timeline.revision_reopened', sourceRef: { type: 'task', id: task.taskId },
-                        lineageConfidence: taskLineageConfidence,
-                    });
-                }
-                const fact = {
-                    schemaVersion: '1', family: 'task', sourceRef: { type: 'task', id: task.taskId }, principleId,
+                revisionIdentities.push(identity);
+                materializedRevisionSources.add(sourceTaskId);
+                derivedRelations.push({
+                    schemaVersion: '1', family: 'derived_relation', sourceRef: { type: 'task', id: task.taskId }, principleId,
                     taskId: task.taskId, lineageConfidence: taskLineageConfidence, recordedAt: task.updatedAt,
-                    occurredAt: task.createdAt, taskKind: task.taskKind, channel: task.channel, status: task.status,
-                    attemptCount: task.attemptCount, maxAttempts: task.maxAttempts,
-                };
-                if (task.leaseExpiresAt !== undefined)
-                    fact.leaseExpiresAt = task.leaseExpiresAt;
-                if (task.lastErrorCategory !== undefined)
-                    fact.lastErrorCategory = task.lastErrorCategory;
-                if (task.revisionIdentity !== undefined) {
-                    fact.revisionIdentity = task.revisionIdentity;
-                }
-                if (task.completionIntent !== undefined)
-                    fact.completionIntent = task.completionIntent;
-                tasks.push(fact);
-                sourceRefs.push(fact.sourceRef);
-                if ((task.taskKind === 'evaluator' || task.taskKind === 'rollout_reviewer') && task.runnerDecision !== undefined) {
-                    runnerVerdicts.push({
-                        schemaVersion: '1', family: 'runner_verdict', sourceRef: fact.sourceRef, principleId,
-                        taskId: task.taskId, lineageConfidence: taskLineageConfidence, recordedAt: task.updatedAt,
-                        runnerKind: task.taskKind, outcome: task.runnerDecision,
-                    });
-                    timelineEvents.push({
-                        code: 'review_started', occurredAt: task.createdAt, recordedAt: task.updatedAt,
-                        summaryCode: 'governance.timeline.review_started', sourceRef: fact.sourceRef, lineageConfidence: taskLineageConfidence,
-                    });
-                    if (task.runnerDecision === 'needs_revision') {
-                        timelineEvents.push({
-                            code: 'revision_requested', occurredAt: task.updatedAt, recordedAt: task.updatedAt,
-                            summaryCode: 'governance.timeline.revision_requested', sourceRef: fact.sourceRef, lineageConfidence: taskLineageConfidence,
-                        });
-                    }
-                }
-                else if ((task.taskKind === 'evaluator' || task.taskKind === 'rollout_reviewer') && task.status === 'succeeded') {
-                    derivedRelations.push({
-                        schemaVersion: '1', family: 'derived_relation', sourceRef: fact.sourceRef, principleId,
-                        taskId: task.taskId, lineageConfidence: taskLineageConfidence, recordedAt: task.updatedAt,
-                        relation: 'verdict_missing', evidenceRefs: [fact.sourceRef],
-                    });
-                }
-                if (task.status === 'failed' || task.status === 'needs_human_review') {
-                    const code = task.status === 'failed' ? 'failed' : 'human_review';
+                    revisionIdentity: identity, relation: 'revision_materialized',
+                    evidenceRefs: [
+                        { type: 'task', id: sourceTaskId },
+                        { type: 'artifact', id: sourceArtifactId },
+                        { type: 'task', id: task.taskId },
+                    ],
+                });
+                timelineEvents.push({
+                    code: 'revision_reopened', occurredAt: task.createdAt, recordedAt: task.updatedAt,
+                    summaryCode: 'governance.timeline.revision_reopened', sourceRef: { type: 'task', id: task.taskId },
+                    lineageConfidence: taskLineageConfidence,
+                });
+            }
+            const fact = {
+                schemaVersion: '1', family: 'task', sourceRef: { type: 'task', id: task.taskId }, principleId,
+                taskId: task.taskId, lineageConfidence: taskLineageConfidence, recordedAt: task.updatedAt,
+                occurredAt: task.createdAt, taskKind: task.taskKind, channel: task.channel, status: task.status,
+                attemptCount: task.attemptCount, maxAttempts: task.maxAttempts,
+            };
+            if (task.leaseExpiresAt !== undefined)
+                fact.leaseExpiresAt = task.leaseExpiresAt;
+            if (task.lastErrorCategory !== undefined)
+                fact.lastErrorCategory = task.lastErrorCategory;
+            if (task.revisionIdentity !== undefined) {
+                fact.revisionIdentity = task.revisionIdentity;
+            }
+            if (task.completionIntent !== undefined)
+                fact.completionIntent = task.completionIntent;
+            tasks.push(fact);
+            sourceRefs.push(fact.sourceRef);
+            if ((task.taskKind === 'evaluator' || task.taskKind === 'rollout_reviewer') && task.runnerDecision !== undefined) {
+                runnerVerdicts.push({
+                    schemaVersion: '1', family: 'runner_verdict', sourceRef: fact.sourceRef, principleId,
+                    taskId: task.taskId, lineageConfidence: taskLineageConfidence, recordedAt: task.updatedAt,
+                    runnerKind: task.taskKind, outcome: task.runnerDecision,
+                });
+                timelineEvents.push({
+                    code: 'review_started', occurredAt: task.createdAt, recordedAt: task.updatedAt,
+                    summaryCode: 'governance.timeline.review_started', sourceRef: fact.sourceRef, lineageConfidence: taskLineageConfidence,
+                });
+                if (task.runnerDecision === 'needs_revision') {
                     timelineEvents.push({
-                        code, occurredAt: task.updatedAt, recordedAt: task.updatedAt,
-                        summaryCode: `governance.timeline.${code}`, sourceRef: fact.sourceRef, lineageConfidence: taskLineageConfidence,
+                        code: 'revision_requested', occurredAt: task.updatedAt, recordedAt: task.updatedAt,
+                        summaryCode: 'governance.timeline.revision_requested', sourceRef: fact.sourceRef, lineageConfidence: taskLineageConfidence,
                     });
                 }
             }
-            tasks.sort((left, right) => (left.taskId ?? '').localeCompare(right.taskId ?? ''));
-            const strongTaskIds = new Set(tasks.filter(task => task.lineageConfidence === 'strong').map(task => task.taskId).filter((taskId) => taskId !== undefined));
-            for (const task of tasks) {
-                const { taskId } = task;
-                if (taskId === undefined || task.completionIntent?.status !== 'pending' || materializedRevisionSources.has(taskId))
-                    continue;
+            else if ((task.taskKind === 'evaluator' || task.taskKind === 'rollout_reviewer') && task.status === 'succeeded') {
                 derivedRelations.push({
-                    schemaVersion: '1', family: 'derived_relation', sourceRef: task.sourceRef, principleId,
-                    taskId, lineageConfidence: 'strong', recordedAt: task.recordedAt,
-                    relation: 'revision_pending', evidenceRefs: [task.sourceRef],
+                    schemaVersion: '1', family: 'derived_relation', sourceRef: fact.sourceRef, principleId,
+                    taskId: task.taskId, lineageConfidence: taskLineageConfidence, recordedAt: task.updatedAt,
+                    relation: 'verdict_missing', evidenceRefs: [fact.sourceRef],
                 });
             }
-            for (const successor of [...validTasks.values()].sort((left, right) => left.taskId.localeCompare(right.taskId))) {
-                if (!strongTaskIds.has(successor.taskId))
-                    continue;
-                for (const dependencyTaskId of [...successor.dependencyTaskIds].sort()) {
-                    if (!strongTaskIds.has(dependencyTaskId))
-                        continue;
-                    derivedRelations.push({
-                        schemaVersion: '1', family: 'derived_relation', sourceRef: { type: 'task', id: dependencyTaskId }, principleId,
-                        taskId: dependencyTaskId, lineageConfidence: 'strong', recordedAt: successor.updatedAt,
-                        relation: 'successor_present',
-                        evidenceRefs: [{ type: 'task', id: dependencyTaskId }, { type: 'task', id: successor.taskId }],
-                    });
-                }
-            }
-            const approvals = [];
-            const activations = [];
-            for (const row of db.prepare('SELECT * FROM approvals ORDER BY approval_id ASC').all()) {
-                if (!isRecord(row))
-                    continue;
-                const artifactId = readOwnString(row, 'artifact_id');
-                if (artifactId === undefined || !strongArtifactIds.has(artifactId))
-                    continue;
-                const approvalId = readOwnString(row, 'approval_id');
-                const channel = readOwnString(row, 'channel');
-                const outcome = readOwnString(row, 'status');
-                const requestedAt = readOwnString(row, 'requested_at');
-                const decidedAt = readOwnString(row, 'decided_at');
-                const approvalRef = approvalId === undefined ? undefined : { type: 'approval', id: approvalId };
-                if (approvalId === undefined || !isGovernanceChannel(channel) || !isTimestamp(requestedAt)
-                    || (outcome !== 'pending' && outcome !== 'approved' && outcome !== 'rejected' && outcome !== 'cancelled')
-                    || (decidedAt !== undefined && !isTimestamp(decidedAt))) {
-                    collectionIssues.push(issue(approvalRef === undefined
-                        ? { source: 'approval', reasonCode: 'metadata_malformed', nextActionCode: 'repair_approval_record' }
-                        : { source: 'approval', reasonCode: 'metadata_malformed', nextActionCode: 'repair_approval_record', sourceRef: approvalRef }));
-                    continue;
-                }
-                const strongApprovalRef = { type: 'approval', id: approvalId };
-                const fact = {
-                    schemaVersion: '1', family: 'approval', sourceRef: strongApprovalRef, principleId, artifactId,
-                    approvalId, channel, outcome, lineageConfidence: 'strong', recordedAt: decidedAt ?? requestedAt,
-                };
-                if (decidedAt !== undefined)
-                    fact.occurredAt = decidedAt;
-                approvals.push(fact);
-                sourceRefs.push(strongApprovalRef);
-                if (outcome === 'approved' || outcome === 'rejected') {
-                    timelineEvents.push({
-                        code: outcome, occurredAt: decidedAt ?? requestedAt, recordedAt: decidedAt ?? requestedAt,
-                        summaryCode: `governance.timeline.${outcome}`, sourceRef: strongApprovalRef, lineageConfidence: 'strong',
-                    });
-                }
+            if (task.status === 'failed' || task.status === 'needs_human_review') {
+                const code = task.status === 'failed' ? 'failed' : 'human_review';
+                timelineEvents.push({
+                    code, occurredAt: task.updatedAt, recordedAt: task.updatedAt,
+                    summaryCode: `governance.timeline.${code}`, sourceRef: fact.sourceRef, lineageConfidence: taskLineageConfidence,
+                });
             }
-            for (const row of db.prepare('SELECT * FROM activations ORDER BY activated_at ASC, activation_id ASC').all()) {
-                if (!isRecord(row))
-                    continue;
-                const artifactId = readOwnString(row, 'artifact_id');
-                if (artifactId === undefined || !strongArtifactIds.has(artifactId))
-                    continue;
-                const activationId = readOwnString(row, 'activation_id');
-                const channel = readOwnString(row, 'channel');
-                const activatedAt = readOwnString(row, 'activated_at');
-                const deactivatedAt = readOwnString(row, 'deactivated_at');
-                const activationRef = activationId === undefined ? undefined : { type: 'activation', id: activationId };
-                if (activationId === undefined || !isGovernanceChannel(channel) || !isTimestamp(activatedAt)
-                    || (deactivatedAt !== undefined && !isTimestamp(deactivatedAt))) {
-                    collectionIssues.push(issue(activationRef === undefined
-                        ? { source: 'activation', reasonCode: 'metadata_malformed', nextActionCode: 'repair_activation_record' }
-                        : { source: 'activation', reasonCode: 'metadata_malformed', nextActionCode: 'repair_activation_record', sourceRef: activationRef }));
+        }
+        tasks.sort((left, right) => (left.taskId ?? '').localeCompare(right.taskId ?? ''));
+        const strongTaskIds = new Set(tasks.filter(task => task.lineageConfidence === 'strong').map(task => task.taskId).filter((taskId) => taskId !== undefined));
+        for (const task of tasks) {
+            const { taskId } = task;
+            if (taskId === undefined || task.completionIntent?.status !== 'pending' || materializedRevisionSources.has(taskId))
+                continue;
+            derivedRelations.push({
+                schemaVersion: '1', family: 'derived_relation', sourceRef: task.sourceRef, principleId,
+                taskId, lineageConfidence: 'strong', recordedAt: task.recordedAt,
+                relation: 'revision_pending', evidenceRefs: [task.sourceRef],
+            });
+        }
+        for (const successor of [...validTasks.values()].sort((left, right) => left.taskId.localeCompare(right.taskId))) {
+            if (!strongTaskIds.has(successor.taskId))
+                continue;
+            for (const dependencyTaskId of [...successor.dependencyTaskIds].sort()) {
+                if (!strongTaskIds.has(dependencyTaskId))
                     continue;
-                }
-                const strongActivationRef = { type: 'activation', id: activationId };
-                const fact = {
-                    schemaVersion: '1', family: 'activation', sourceRef: strongActivationRef, principleId, artifactId,
-                    activationId, channel, outcome: deactivatedAt === undefined ? 'active' : 'deactivated',
-                    activatedAt, lineageConfidence: 'strong', recordedAt: deactivatedAt ?? activatedAt,
-                };
-                if (deactivatedAt !== undefined)
-                    fact.deactivatedAt = deactivatedAt;
-                activations.push(fact);
-                sourceRefs.push(strongActivationRef);
-                timelineEvents.push({ code: 'activated', occurredAt: activatedAt, recordedAt: activatedAt, summaryCode: 'governance.timeline.activated', sourceRef: strongActivationRef, lineageConfidence: 'strong' });
-                if (deactivatedAt !== undefined) {
-                    timelineEvents.push({ code: 'deactivated', occurredAt: deactivatedAt, recordedAt: deactivatedAt, summaryCode: 'governance.timeline.deactivated', sourceRef: strongActivationRef, lineageConfidence: 'strong' });
-                }
+                derivedRelations.push({
+                    schemaVersion: '1', family: 'derived_relation', sourceRef: { type: 'task', id: dependencyTaskId }, principleId,
+                    taskId: dependencyTaskId, lineageConfidence: 'strong', recordedAt: successor.updatedAt,
+                    relation: 'successor_present',
+                    evidenceRefs: [{ type: 'task', id: dependencyTaskId }, { type: 'task', id: successor.taskId }],
+                });
             }
-            timelineEvents.sort((left, right) => {
-                const timeOrder = (left.occurredAt ?? left.recordedAt).localeCompare(right.occurredAt ?? right.recordedAt);
-                if (timeOrder !== 0)
-                    return timeOrder;
-                const typeOrder = left.sourceRef.type.localeCompare(right.sourceRef.type);
-                if (typeOrder !== 0)
-                    return typeOrder;
-                const idOrder = left.sourceRef.id.localeCompare(right.sourceRef.id);
-                return idOrder !== 0 ? idOrder : left.code.localeCompare(right.code);
-            });
-            return GovernanceProjectionCollector.finish({
-                principleId, asOf, principle, collectionIssues, artifactIds,
-                taskIds: tasks.map(task => task.taskId).filter((taskId) => taskId !== undefined).sort(), tasks, revisionIdentities, sourceRefs,
-                runnerVerdicts, derivedRelations, approvals, activations, timelineEvents,
-            });
         }
-        catch (error) {
-            if (error instanceof GovernanceProjectionCollectionError)
-                throw error;
-            throw new GovernanceProjectionCollectionError('governance_projection_error', 'inspect_runtime_state');
+        const approvals = [];
+        const activations = [];
+        for (const row of tables.approvalRows) {
+            if (!isRecord(row))
+                continue;
+            const artifactId = readOwnString(row, 'artifact_id');
+            if (artifactId === undefined || !strongArtifactIds.has(artifactId))
+                continue;
+            const approvalId = readOwnString(row, 'approval_id');
+            const channel = readOwnString(row, 'channel');
+            const outcome = readOwnString(row, 'status');
+            const requestedAt = readOwnString(row, 'requested_at');
+            const decidedAt = readOwnString(row, 'decided_at');
+            const approvalRef = approvalId === undefined ? undefined : { type: 'approval', id: approvalId };
+            if (approvalId === undefined || !isGovernanceChannel(channel) || !isTimestamp(requestedAt)
+                || (outcome !== 'pending' && outcome !== 'approved' && outcome !== 'rejected' && outcome !== 'cancelled')
+                || (decidedAt !== undefined && !isTimestamp(decidedAt))) {
+                collectionIssues.push(issue(approvalRef === undefined
+                    ? { source: 'approval', reasonCode: 'metadata_malformed', nextActionCode: 'repair_approval_record' }
+                    : { source: 'approval', reasonCode: 'metadata_malformed', nextActionCode: 'repair_approval_record', sourceRef: approvalRef }));
+                continue;
+            }
+            const strongApprovalRef = { type: 'approval', id: approvalId };
+            const fact = {
+                schemaVersion: '1', family: 'approval', sourceRef: strongApprovalRef, principleId, artifactId,
+                approvalId, channel, outcome, lineageConfidence: 'strong', recordedAt: decidedAt ?? requestedAt,
+            };
+            if (decidedAt !== undefined)
+                fact.occurredAt = decidedAt;
+            approvals.push(fact);
+            sourceRefs.push(strongApprovalRef);
+            if (outcome === 'approved' || outcome === 'rejected') {
+                timelineEvents.push({
+                    code: outcome, occurredAt: decidedAt ?? requestedAt, recordedAt: decidedAt ?? requestedAt,
+                    summaryCode: `governance.timeline.${outcome}`, sourceRef: strongApprovalRef, lineageConfidence: 'strong',
+                });
+            }
         }
-        finally {
-            connection.close();
+        for (const row of tables.activationRows) {
+            if (!isRecord(row))
+                continue;
+            const artifactId = readOwnString(row, 'artifact_id');
+            if (artifactId === undefined || !strongArtifactIds.has(artifactId))
+                continue;
+            const activationId = readOwnString(row, 'activation_id');
+            const channel = readOwnString(row, 'channel');
+            const activatedAt = readOwnString(row, 'activated_at');
+            const deactivatedAt = readOwnString(row, 'deactivated_at');
+            const activationRef = activationId === undefined ? undefined : { type: 'activation', id: activationId };
+            if (activationId === undefined || !isGovernanceChannel(channel) || !isTimestamp(activatedAt)
+                || (deactivatedAt !== undefined && !isTimestamp(deactivatedAt))) {
+                collectionIssues.push(issue(activationRef === undefined
+                    ? { source: 'activation', reasonCode: 'metadata_malformed', nextActionCode: 'repair_activation_record' }
+                    : { source: 'activation', reasonCode: 'metadata_malformed', nextActionCode: 'repair_activation_record', sourceRef: activationRef }));
+                continue;
+            }
+            const strongActivationRef = { type: 'activation', id: activationId };
+            const fact = {
+                schemaVersion: '1', family: 'activation', sourceRef: strongActivationRef, principleId, artifactId,
+                activationId, channel, outcome: deactivatedAt === undefined ? 'active' : 'deactivated',
+                activatedAt, lineageConfidence: 'strong', recordedAt: deactivatedAt ?? activatedAt,
+            };
+            if (deactivatedAt !== undefined)
+                fact.deactivatedAt = deactivatedAt;
+            activations.push(fact);
+            sourceRefs.push(strongActivationRef);
+            timelineEvents.push({ code: 'activated', occurredAt: activatedAt, recordedAt: activatedAt, summaryCode: 'governance.timeline.activated', sourceRef: strongActivationRef, lineageConfidence: 'strong' });
+            if (deactivatedAt !== undefined) {
+                timelineEvents.push({ code: 'deactivated', occurredAt: deactivatedAt, recordedAt: deactivatedAt, summaryCode: 'governance.timeline.deactivated', sourceRef: strongActivationRef, lineageConfidence: 'strong' });
+            }
         }
+        timelineEvents.sort((left, right) => {
+            const timeOrder = (left.occurredAt ?? left.recordedAt).localeCompare(right.occurredAt ?? right.recordedAt);
+            if (timeOrder !== 0)
+                return timeOrder;
+            const typeOrder = left.sourceRef.type.localeCompare(right.sourceRef.type);
+            if (typeOrder !== 0)
+                return typeOrder;
+            const idOrder = left.sourceRef.id.localeCompare(right.sourceRef.id);
+            return idOrder !== 0 ? idOrder : left.code.localeCompare(right.code);
+        });
+        return GovernanceProjectionCollector.finish({
+            principleId, asOf, principle, collectionIssues, artifactIds,
+            taskIds: tasks.map(task => task.taskId).filter((taskId) => taskId !== undefined).sort(), tasks, revisionIdentities, sourceRefs,
+            runnerVerdicts, derivedRelations, approvals, activations, timelineEvents,
+        });
     }
     readPrinciple(principleId, issues) {
-        const ledgerPath = path.join(this.workspaceDir, '.state', 'principle_training_state.json');
-        let parsed;
+        return GovernanceProjectionCollector.principleFactFromLedger(GovernanceProjectionCollector.parsePrincipleLedgerFile(this.workspaceDir), principleId, issues);
+    }
+    /** Reads and JSON-parses the principle ledger file (shared by single + batch collectors). */
+    static parsePrincipleLedgerFile(workspaceDir) {
+        const ledgerPath = path.join(workspaceDir, '.state', 'principle_training_state.json');
         try {
-            parsed = JSON.parse(fs.readFileSync(ledgerPath, 'utf8'));
+            return JSON.parse(fs.readFileSync(ledgerPath, 'utf8'));
         }
         catch {
             throw new GovernanceProjectionCollectionError('principle_not_found', 'check_principle_ledger');
         }
+    }
+    /** Extracts the principles record from a parsed ledger; null when the tree is absent/malformed. */
+    static principleTreeFromLedger(parsed) {
         if (!isRecord(parsed))
-            throw new GovernanceProjectionCollectionError('principle_not_found', 'check_principle_ledger');
+            return null;
         const tree = Object.hasOwn(parsed, '_tree') ? parsed._tree : parsed.tree;
-        if (!isRecord(tree) || !isRecord(tree.principles) || !Object.hasOwn(tree.principles, principleId)) {
+        if (!isRecord(tree) || !isRecord(tree.principles))
+            return null;
+        return tree.principles;
+    }
+    /** Validates one principle entry from an already-parsed ledger (shared by single + batch collectors). */
+    static principleFactFromLedger(parsed, principleId, issues) {
+        if (!isRecord(parsed))
+            throw new GovernanceProjectionCollectionError('principle_not_found', 'check_principle_ledger');
+        const principles = GovernanceProjectionCollector.principleTreeFromLedger(parsed);
+        if (principles === null || !Object.hasOwn(principles, principleId)) {
             throw new GovernanceProjectionCollectionError('principle_not_found', 'check_principle_id');
         }
-        const raw = tree.principles[principleId];
+        const raw = principles[principleId];
         if (!isRecord(raw))
             throw new GovernanceProjectionCollectionError('principle_not_found', 'repair_principle_ledger');
         const state = readOwnString(raw, 'status');
@@ -428,7 +466,7 @@ export class GovernanceProjectionCollector {
         }
         if (taskKind !== 'dreamer' && taskKind !== 'philosopher' && taskKind !== 'scribe' && taskKind !== 'artificer' && taskKind !== 'evaluator' && taskKind !== 'rollout_reviewer')
             return null;
-        if (status !== 'pending' && status !== 'leased' && status !== 'succeeded' && status !== 'retry_wait' && status !== 'failed' && status !== 'needs_human_review')
+        if (!isPDTaskStatus(status))
             return null;
         const result = { taskId, taskKind, status, createdAt, updatedAt, attemptCount, maxAttempts, channel, dependencyTaskIds: metadata.dependencyTaskIds };
         const leaseExpiresAt = readOwnString(row, 'lease_expires_at');