principles-disciple 1.8.0 → 1.8.1

package/dist/service/health-query-service.js

@@ -0,0 +1,662 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { readPainFlagData } from '../core/pain.js';
+import { resolvePdPath } from '../core/paths.js';
+import { listSessions } from '../core/session-tracker.js';
+import { listDeployments } from '../core/model-deployment-registry.js';
+import { ControlUiDatabase } from '../core/control-ui-db.js';
+import { WorkspaceContext } from '../core/workspace-context.js';
+export class HealthQueryService {
+    workspaceDir;
+    stateDir;
+    trajectory;
+    config;
+    eventLog;
+    evolutionReducer;
+    uiDb;
+    tableColumnCache = new Map();
+    constructor(workspaceDir) {
+        this.workspaceDir = workspaceDir;
+        const wctx = WorkspaceContext.fromHookContext({ workspaceDir });
+        this.stateDir = wctx.stateDir;
+        this.trajectory = wctx.trajectory;
+        this.config = wctx.config;
+        this.eventLog = wctx.eventLog;
+        this.evolutionReducer = wctx.evolutionReducer;
+        this.uiDb = new ControlUiDatabase({ workspaceDir });
+    }
+    dispose() {
+        this.uiDb.dispose();
+    }
+    getOverviewHealth() {
+        const session = this.getCurrentSession();
+        const threshold = this.getGfiThreshold();
+        const trust = this.readTrust();
+        const evolution = this.readEvolutionScore();
+        const reducerStats = this.evolutionReducer.getStats();
+        const queue = this.readQueueStats();
+        const painFlag = this.readPainFlag();
+        const currentGfi = this.asNumber(session?.currentGfi, 0);
+        const peakToday = this.asNumber(session?.dailyGfiPeak, currentGfi);
+        return {
+            gfi: {
+                current: currentGfi,
+                peakToday,
+                threshold,
+            },
+            trust,
+            evolution,
+            painFlag,
+            principles: {
+                candidate: reducerStats.candidateCount,
+                probation: reducerStats.probationCount,
+                active: reducerStats.activeCount,
+                deprecated: reducerStats.deprecatedCount,
+            },
+            queue,
+            activeStage: this.computeHealthStage(currentGfi, threshold, painFlag.active),
+        };
+    }
+    getEvolutionPrinciples() {
+        const stats = this.evolutionReducer.getStats();
+        const recent = this.readRecentPrincipleChanges(30);
+        const nocturnal = this.readNocturnalTraining();
+        const painSourceDistribution = this.readPainSourceDistribution();
+        const activeStage = this.readEvolutionActiveStage(nocturnal.queue);
+        return {
+            principles: {
+                summary: {
+                    candidate: stats.candidateCount,
+                    probation: stats.probationCount,
+                    active: stats.activeCount,
+                    deprecated: stats.deprecatedCount,
+                },
+                recent,
+            },
+            nocturnalTraining: nocturnal,
+            painSourceDistribution,
+            activeStage,
+        };
+    }
+    getFeedbackGfi() {
+        const session = this.getCurrentSession();
+        const threshold = this.getGfiThreshold();
+        const today = new Date().toISOString().slice(0, 10);
+        const trendRows = this.uiDb.all(`
+      SELECT substr(created_at, 1, 13) || ':00:00Z' AS hour, ROUND(SUM(score), 2) AS value
+      FROM pain_events
+      WHERE substr(created_at, 1, 10) = ?
+      GROUP BY substr(created_at, 1, 13)
+      ORDER BY hour ASC
+    `, today);
+        const sourceRows = this.uiDb.all(`
+      SELECT source, COUNT(*) AS total
+      FROM pain_events
+      WHERE substr(created_at, 1, 10) = ?
+      GROUP BY source
+      ORDER BY total DESC
+    `, today);
+        return {
+            current: this.asNumber(session?.currentGfi, 0),
+            peakToday: this.asNumber(session?.dailyGfiPeak, this.asNumber(session?.currentGfi, 0)),
+            threshold,
+            trend: trendRows.map((row) => ({ hour: row.hour, value: this.asNumber(row.value, 0) })),
+            sources: Object.fromEntries(sourceRows.map((row) => [row.source, this.asNumber(row.total, 0)])),
+        };
+    }
+    getFeedbackEmpathyEvents(limit = 50) {
+        const safeLimit = Math.max(1, Math.min(500, Math.floor(limit)));
+        const events = this.readMergedEvents()
+            .filter((entry) => entry.type === 'pain_signal' && String(entry.data?.source ?? '') === 'user_empathy')
+            .sort((a, b) => (b.ts || '').localeCompare(a.ts || ''))
+            .slice(0, safeLimit);
+        return events.map((entry) => {
+            const data = entry.data ?? {};
+            return {
+                timestamp: String(entry.ts ?? ''),
+                severity: typeof data.severity === 'string' ? data.severity : 'mild',
+                score: this.asNumber(data.score, 0),
+                reason: typeof data.reason === 'string' ? data.reason : '',
+                origin: typeof data.origin === 'string' ? data.origin : 'unknown',
+                gfiAfter: this.asNumber(data.gfiAfter ?? data.gfi_after ?? data.gfi, 0),
+            };
+        });
+    }
+    getFeedbackGateBlocks(limit = 50) {
+        const trust = this.readTrust();
+        const rows = this.readGateBlocksRaw(limit);
+        return rows.map((row) => ({
+            timestamp: row.created_at,
+            toolName: row.tool_name,
+            reason: row.reason,
+            gfi: this.resolveGateBlockGfi(row),
+            trustStage: this.resolveGateBlockTrustStage(row, trust.stage),
+        }));
+    }
+    getGateStats() {
+        const today = new Date().toISOString().slice(0, 10);
+        const rows = this.uiDb.all(`
+      SELECT reason
+      FROM gate_blocks
+      WHERE substr(created_at, 1, 10) = ?
+    `, today);
+        let gfiBlocks = 0;
+        let stageBlocks = 0;
+        let p03Blocks = 0;
+        let bypassAttempts = 0;
+        let p16Exemptions = 0;
+        for (const row of rows) {
+            const reason = String(row.reason || '').toLowerCase();
+            if (reason.includes('gfi'))
+                gfiBlocks++;
+            if (reason.includes('tier') || reason.includes('stage') || reason.includes('trust'))
+                stageBlocks++;
+            if (reason.includes('p-03') || reason.includes('edit verification') || reason.includes('oldtext'))
+                p03Blocks++;
+            if (reason.includes('bypass'))
+                bypassAttempts++;
+            if (reason.includes('p-16') || reason.includes('exemption'))
+                p16Exemptions++;
+        }
+        const trust = this.readTrust();
+        const evolution = this.readEvolutionScore();
+        return {
+            today: {
+                gfiBlocks,
+                stageBlocks,
+                p03Blocks,
+                bypassAttempts,
+                p16Exemptions,
+            },
+            trust: {
+                stage: trust.stage,
+                score: trust.score,
+                status: this.scoreToStatus(trust.score),
+            },
+            evolution: {
+                tier: evolution.tier,
+                points: evolution.points,
+                status: this.evolutionToStatus(evolution.tier, evolution.points),
+            },
+        };
+    }
+    getGateBlocks(limit = 50) {
+        const trust = this.readTrust();
+        const rows = this.readGateBlocksRaw(limit);
+        return rows.map((row) => ({
+            timestamp: row.created_at,
+            toolName: row.tool_name,
+            filePath: row.file_path ?? null,
+            reason: row.reason,
+            gateType: this.resolveGateType(row),
+            gfi: this.resolveGateBlockGfi(row),
+            trustStage: this.resolveGateBlockTrustStage(row, trust.stage),
+        }));
+    }
+    readTrust() {
+        const scorecardPath = resolvePdPath(this.workspaceDir, 'AGENT_SCORECARD');
+        const scorecard = this.readJsonFile(scorecardPath, {});
+        const score = this.asNumber(scorecard.trustScore ?? scorecard.trust_score ?? scorecard.score, 0);
+        const rawStage = this.asNumber(scorecard.trustStage ?? scorecard.trust_stage ?? scorecard.stage, this.inferTrustStageFromScore(score));
+        const stage = Math.max(1, Math.min(4, Math.round(rawStage)));
+        return {
+            stage,
+            stageLabel: this.getTrustStageLabel(stage),
+            score,
+        };
+    }
+    readEvolutionScore() {
+        const scorecardPath = path.join(this.stateDir, 'evolution-scorecard.json');
+        const scorecard = this.readJsonFile(scorecardPath, {});
+        const points = this.asNumber(scorecard.totalPoints ?? scorecard.total_points, 0);
+        const tierRaw = scorecard.currentTier ?? scorecard.current_tier ?? 1;
+        return {
+            tier: this.normalizeTierName(tierRaw),
+            points,
+        };
+    }
+    readQueueStats() {
+        const queuePath = resolvePdPath(this.workspaceDir, 'EVOLUTION_QUEUE');
+        const queue = this.readJsonFile(queuePath, []);
+        const stats = { pending: 0, inProgress: 0, completed: 0 };
+        for (const item of queue) {
+            const status = String(item?.status ?? 'pending');
+            if (status === 'completed')
+                stats.completed++;
+            else if (status === 'in_progress')
+                stats.inProgress++;
+            else
+                stats.pending++;
+        }
+        return stats;
+    }
+    readPainFlag() {
+        const painFlagPath = resolvePdPath(this.workspaceDir, 'PAIN_FLAG');
+        if (!fs.existsSync(painFlagPath)) {
+            return { active: false, source: null, score: null };
+        }
+        const data = readPainFlagData(this.workspaceDir);
+        return {
+            active: true,
+            source: typeof data.source === 'string' ? data.source : null,
+            score: this.asNullableNumber(data.score),
+        };
+    }
+    getCurrentSession() {
+        const sessions = listSessions(this.workspaceDir);
+        if (sessions.length === 0)
+            return null;
+        const sorted = [...sessions].sort((a, b) => {
+            const aTs = Number(a.lastControlActivityAt ?? a.lastActivityAt ?? 0);
+            const bTs = Number(b.lastControlActivityAt ?? b.lastActivityAt ?? 0);
+            return bTs - aTs;
+        });
+        return sorted[0] ?? null;
+    }
+    getGfiThreshold() {
+        const fromConfig = this.asNullableNumber(this.config.get('gfi_gate.thresholds.low_risk_block'));
+        if (fromConfig !== null)
+            return fromConfig;
+        const fallbackPath = resolvePdPath(this.workspaceDir, 'PAIN_SETTINGS');
+        const raw = this.readJsonFile(fallbackPath, {});
+        const fallback = this.asNullableNumber((raw.gfi_gate?.thresholds?.low_risk_block));
+        return fallback ?? 70;
+    }
+    computeHealthStage(currentGfi, threshold, painFlagActive) {
+        if (painFlagActive || currentGfi >= threshold) {
+            return 'critical';
+        }
+        if (currentGfi >= threshold * 0.7) {
+            return 'warning';
+        }
+        return 'healthy';
+    }
+    getTrustStageLabel(stage) {
+        switch (stage) {
+            case 1:
+                return 'Observer';
+            case 2:
+                return 'Editor';
+            case 3:
+                return 'Developer';
+            case 4:
+                return 'Architect';
+            default:
+                return 'Observer';
+        }
+    }
+    inferTrustStageFromScore(score) {
+        if (score >= 80)
+            return 4;
+        if (score >= 60)
+            return 3;
+        if (score >= 30)
+            return 2;
+        return 1;
+    }
+    normalizeTierName(rawTier) {
+        if (typeof rawTier === 'string') {
+            const t = rawTier.trim();
+            if (t.length > 0)
+                return t;
+        }
+        const n = this.asNumber(rawTier, 1);
+        if (n === 1)
+            return 'Seed';
+        if (n === 2)
+            return 'Sprout';
+        if (n === 3)
+            return 'Sapling';
+        if (n === 4)
+            return 'Tree';
+        if (n === 5)
+            return 'Forest';
+        return `Tier-${n}`;
+    }
+    readRecentPrincipleChanges(limit) {
+        const streamPath = resolvePdPath(this.workspaceDir, 'EVOLUTION_STREAM');
+        if (!fs.existsSync(streamPath))
+            return [];
+        let lines = [];
+        try {
+            const raw = fs.readFileSync(streamPath, 'utf8').trim();
+            if (!raw)
+                return [];
+            lines = raw.split('\n');
+        }
+        catch {
+            return [];
+        }
+        const records = [];
+        for (const line of lines) {
+            let event = null;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                event = null;
+            }
+            if (!event?.type || !event.data)
+                continue;
+            const mapped = this.mapPrincipleEvent(event);
+            if (mapped)
+                records.push(mapped);
+        }
+        return records
+            .sort((a, b) => b.timestamp.localeCompare(a.timestamp))
+            .slice(0, Math.max(1, Math.min(200, limit)));
+    }
+    mapPrincipleEvent(event) {
+        const data = event.data ?? {};
+        const type = String(event.type);
+        const principleId = typeof data.principleId === 'string' ? data.principleId : '';
+        if (!principleId)
+            return null;
+        const principle = this.evolutionReducer.getPrincipleById(principleId);
+        const triggerPattern = typeof data.trigger === 'string'
+            ? data.trigger
+            : typeof principle?.trigger === 'string'
+                ? principle.trigger
+                : '';
+        const action = typeof data.action === 'string'
+            ? data.action
+            : typeof principle?.action === 'string'
+                ? principle.action
+                : '';
+        if (type === 'candidate_created') {
+            const toStatus = typeof data.status === 'string' ? data.status : 'candidate';
+            return {
+                principleId,
+                status: toStatus,
+                triggerPattern,
+                action,
+                fromStatus: 'none',
+                toStatus,
+                timestamp: String(event.ts ?? ''),
+            };
+        }
+        if (type === 'principle_promoted') {
+            const fromStatus = typeof data.from === 'string' ? data.from : 'candidate';
+            const toStatus = typeof data.to === 'string' ? data.to : 'probation';
+            return {
+                principleId,
+                status: toStatus,
+                triggerPattern,
+                action,
+                fromStatus,
+                toStatus,
+                timestamp: String(event.ts ?? ''),
+            };
+        }
+        if (type === 'principle_deprecated') {
+            return {
+                principleId,
+                status: 'deprecated',
+                triggerPattern,
+                action,
+                fromStatus: 'active',
+                toStatus: 'deprecated',
+                timestamp: String(event.ts ?? ''),
+            };
+        }
+        if (type === 'principle_rolled_back') {
+            return {
+                principleId,
+                status: 'deprecated',
+                triggerPattern,
+                action,
+                fromStatus: 'probation',
+                toStatus: 'deprecated',
+                timestamp: String(event.ts ?? ''),
+            };
+        }
+        return null;
+    }
+    readNocturnalTraining() {
+        const sampleDir = resolvePdPath(this.workspaceDir, 'NOCTURNAL_SAMPLES_DIR');
+        const exportDir = resolvePdPath(this.workspaceDir, 'NOCTURNAL_EXPORTS_DIR');
+        const reviewQueuePath = path.join(this.stateDir, 'nocturnal', 'review-queue.json');
+        const sampleFiles = this.safeListFiles(sampleDir, (name) => name.endsWith('.json') && name !== 'lineage-index.json');
+        const samples = sampleFiles.map((filePath) => this.readJsonFile(filePath, {}));
+        const queue = { pending: 0, inProgress: 0, completed: 0 };
+        for (const sample of samples) {
+            const status = String(sample.status ?? '').toLowerCase();
+            if (status === 'in_progress' || status === 'running')
+                queue.inProgress++;
+            else if (status === 'pending' || status === 'pending_review')
+                queue.pending++;
+            else
+                queue.completed++;
+        }
+        const reviewQueue = this.readJsonFile(reviewQueuePath, []);
+        queue.pending += reviewQueue.length;
+        const trinityRecords = samples
+            .map((sample) => ({
+            artifactId: String(sample.artifactId ?? ''),
+            status: String(sample.status ?? 'unknown'),
+            createdAt: String(sample.createdAt ?? ''),
+        }))
+            .filter((row) => row.artifactId.length > 0)
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+            .slice(0, 20);
+        let passed = 0;
+        for (const sample of samples) {
+            const status = String(sample.status ?? '').toLowerCase();
+            const arbiterPassed = sample.arbiter?.passed === true;
+            if (arbiterPassed || status === 'approved' || status === 'approved_for_training') {
+                passed++;
+            }
+        }
+        const total = samples.length;
+        const arbiterPassRate = total > 0 ? Number((passed / total).toFixed(4)) : 0;
+        const exportFiles = this.safeListFiles(exportDir, (name) => name.endsWith('.jsonl'));
+        const orpoSampleCount = exportFiles.length;
+        const deployments = listDeployments(this.stateDir).map((deployment) => ({
+            modelId: deployment.workerProfile,
+            status: deployment.routingEnabled ? 'active' : 'inactive',
+            checkpointPath: deployment.activeCheckpointId,
+        }));
+        return {
+            queue,
+            trinityRecords,
+            arbiterPassRate,
+            orpoSampleCount,
+            deployments,
+        };
+    }
+    readPainSourceDistribution() {
+        const rows = this.uiDb.all(`
+      SELECT source, COUNT(*) AS total
+      FROM pain_events
+      GROUP BY source
+      ORDER BY total DESC
+    `);
+        return Object.fromEntries(rows.map((row) => [row.source, this.asNumber(row.total, 0)]));
+    }
+    readEvolutionActiveStage(queue) {
+        const events = this.trajectory.listEvolutionEvents(undefined, { limit: 1, offset: 0 });
+        if (events.length > 0) {
+            return events[0].stage;
+        }
+        if (queue.inProgress > 0)
+            return 'in_progress';
+        if (queue.pending > 0)
+            return 'pending';
+        if (queue.completed > 0)
+            return 'completed';
+        return 'idle';
+    }
+    readMergedEvents() {
+        const persistedEvents = this.readPersistedEvents();
+        const bufferedEvents = this.getBufferedEvents();
+        const merged = new Map();
+        for (const entry of [...persistedEvents, ...bufferedEvents]) {
+            merged.set(this.getEventDedupKey(entry), entry);
+        }
+        return [...merged.values()].sort((a, b) => (a.ts || '').localeCompare(b.ts || ''));
+    }
+    readPersistedEvents() {
+        const eventsPath = path.join(this.stateDir, 'logs', 'events.jsonl');
+        if (!fs.existsSync(eventsPath))
+            return [];
+        try {
+            const raw = fs.readFileSync(eventsPath, 'utf8').trim();
+            if (!raw)
+                return [];
+            return raw
+                .split('\n')
+                .map((line) => {
+                try {
+                    return JSON.parse(line);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .filter((entry) => entry !== null);
+        }
+        catch {
+            return [];
+        }
+    }
+    getBufferedEvents() {
+        const candidate = this.eventLog;
+        if (typeof candidate.getBufferedEvents === 'function') {
+            return candidate.getBufferedEvents();
+        }
+        return [];
+    }
+    getEventDedupKey(entry) {
+        const eventId = typeof entry.data?.eventId === 'string' ? entry.data.eventId : null;
+        if (eventId) {
+            return `${entry.type}:${entry.sessionId ?? 'none'}:${eventId}`;
+        }
+        return [
+            entry.ts ?? 'no-ts',
+            entry.type ?? 'no-type',
+            entry.category ?? 'no-category',
+            entry.sessionId ?? 'no-session',
+            typeof entry.data?.source === 'string' ? entry.data.source : 'no-source',
+            typeof entry.data?.toolName === 'string' ? entry.data.toolName : 'no-tool',
+            typeof entry.data?.reason === 'string' ? entry.data.reason : 'no-reason',
+        ].join('::');
+    }
+    readGateBlocksRaw(limit) {
+        const safeLimit = Math.max(1, Math.min(1000, Math.floor(limit)));
+        const hasGfi = this.hasTableColumn('gate_blocks', 'gfi');
+        const hasGfiAfter = this.hasTableColumn('gate_blocks', 'gfi_after');
+        const hasTrustStage = this.hasTableColumn('gate_blocks', 'trust_stage');
+        const hasGateType = this.hasTableColumn('gate_blocks', 'gate_type');
+        const sql = `
+      SELECT
+        created_at,
+        tool_name,
+        file_path,
+        reason,
+        ${hasGfi ? 'gfi' : 'NULL'} AS gfi,
+        ${hasGfiAfter ? 'gfi_after' : 'NULL'} AS gfi_after,
+        ${hasTrustStage ? 'trust_stage' : 'NULL'} AS trust_stage,
+        ${hasGateType ? 'gate_type' : 'NULL'} AS gate_type
+      FROM gate_blocks
+      ORDER BY created_at DESC
+      LIMIT ?
+    `;
+        return this.uiDb.all(sql, safeLimit);
+    }
+    resolveGateBlockGfi(row) {
+        const direct = this.asNullableNumber(row.gfi ?? row.gfi_after);
+        if (direct !== null)
+            return direct;
+        const reason = String(row.reason ?? '');
+        const match = reason.match(/gfi\s*[:=]\s*(-?\d+(?:\.\d+)?)/i);
+        if (match) {
+            return this.asNumber(Number(match[1]), 0);
+        }
+        const session = this.getCurrentSession();
+        return this.asNumber(session?.currentGfi, 0);
+    }
+    resolveGateBlockTrustStage(row, fallbackStage) {
+        const direct = this.asNullableNumber(row.trust_stage);
+        if (direct !== null)
+            return Math.max(1, Math.min(4, Math.round(direct)));
+        const reason = String(row.reason ?? '').toLowerCase();
+        const match = reason.match(/stage\s*(\d+)/i);
+        if (match) {
+            return Math.max(1, Math.min(4, Math.round(this.asNumber(Number(match[1]), fallbackStage))));
+        }
+        return fallbackStage;
+    }
+    resolveGateType(row) {
+        if (typeof row.gate_type === 'string' && row.gate_type.trim().length > 0) {
+            return row.gate_type;
+        }
+        const reason = String(row.reason ?? '').toLowerCase();
+        if (reason.includes('gfi'))
+            return 'gfi';
+        if (reason.includes('tier') || reason.includes('stage') || reason.includes('trust'))
+            return 'stage';
+        if (reason.includes('p-03') || reason.includes('edit verification') || reason.includes('oldtext'))
+            return 'p03';
+        if (reason.includes('p-16') || reason.includes('exemption'))
+            return 'p16';
+        return 'general';
+    }
+    hasTableColumn(tableName, columnName) {
+        let cached = this.tableColumnCache.get(tableName);
+        if (!cached) {
+            const rows = this.uiDb.all(`PRAGMA table_info(${tableName})`);
+            cached = new Set(rows.map((row) => row.name));
+            this.tableColumnCache.set(tableName, cached);
+        }
+        return cached.has(columnName);
+    }
+    scoreToStatus(score) {
+        if (score >= 70)
+            return 'healthy';
+        if (score >= 40)
+            return 'warning';
+        return 'critical';
+    }
+    evolutionToStatus(tier, points) {
+        const lower = tier.toLowerCase();
+        if (lower === 'forest' || lower === 'tree')
+            return 'healthy';
+        if (lower === 'sapling' || points >= 200)
+            return 'warning';
+        return 'critical';
+    }
+    safeListFiles(dirPath, predicate) {
+        if (!fs.existsSync(dirPath))
+            return [];
+        try {
+            return fs.readdirSync(dirPath)
+                .filter((name) => predicate(name))
+                .map((name) => path.join(dirPath, name));
+        }
+        catch {
+            return [];
+        }
+    }
+    readJsonFile(filePath, fallback) {
+        if (!fs.existsSync(filePath))
+            return fallback;
+        try {
+            return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+        }
+        catch {
+            return fallback;
+        }
+    }
+    asNumber(value, fallback) {
+        return Number.isFinite(value) ? Number(value) : fallback;
+    }
+    asNullableNumber(value) {
+        if (Number.isFinite(value))
+            return Number(value);
+        if (typeof value === 'string' && value.trim().length > 0) {
+            const n = Number(value);
+            return Number.isFinite(n) ? n : null;
+        }
+        return null;
+    }
+}

package/dist/service/nocturnal-runtime.d.ts

@@ -68,8 +68,8 @@ export interface IdleCheckResult {
     mostRecentActivityAt: number;
     /** How long since the last activity (ms) */
     idleForMs: number;
-    /** Number of active (non-abandoned) sessions found */
-    activeSessionCount: number;
+    /** Number of active (non-abandoned) user sessions found */
+    userActiveSessions: number;
     /** List of abandoned session IDs (inactive > abandoned threshold) */
     abandonedSessionIds: string[];
     /** Whether trajectory guardrail also confirms idle */