@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
620 lines • 87.6 kB
JavaScript
/**
* Autonomy Evaluator Service
*
* Determines whether an agent should continue autonomously or pause
* for human input after each step. This is the brain that enables
* automatic continue/pause decisions in the agentic loop.
*
* Decision factors:
* 1. Step count vs maxAutonomousSteps
* 2. Next action vs requiresApproval patterns
* 3. Safety tier (ALLOW/VERIFY/DENY)
* 4. Risk tolerance configuration
*
* ## Danger Zone Verification Flow (Issue #142)
*
* When an agent action triggers the DANGER_ZONE or VERIFY safety tier,
* a human-in-the-loop verification is required before the agent can proceed.
*
* End-to-end sequence:
*
* 1. Agent proposes an action (nextActionHint) during agentic loop
* 2. evaluateAutonomy() calls checkSafetyTier() → returns DANGER_ZONE or VERIFY
* 3. createVerificationChallenge() generates a challenge with:
* - challengeId (UUID v4 via crypto.randomUUID)
* - displayCode (human-readable code, e.g. "ABC123")
* - expiresAt (configurable, default 5 minutes)
* 4. storeAndDisplayChallenge():
* a. Stores {code, expiresAt, reason} in VerificationStore (server-side, one-time use)
* b. Shows displayCode to human via OS-native dialog (AppleScript/zenity/PowerShell)
* c. displayCode is NEVER included in the LLM-facing directive
* 5. For DANGER_ZONE: DangerZoneEnforcer.block() programmatically blocks the agent
* with verificationId=challengeId (file-backed, survives restarts)
* 6. LLM receives directive with verification.verificationId but NO displayCode
* plus actionable guidance: "Use verify_challenge { challenge_id, code }"
* 7. Human reads code from OS dialog, tells LLM
* 8. LLM calls verify_challenge MCP-AQL operation
* 9. MCPAQLHandler verify handler:
* a. Validates UUID v4 format (rejects invalid IDs before store lookup)
* b. Checks rate limit (max 10 failures per 60s sliding window)
* c. Distinguishes expired (VERIFICATION_EXPIRED) from wrong code (VERIFICATION_FAILED)
* d. On success: finds blocked agent by challengeId → DangerZoneEnforcer.unblock()
* e. Logs granular security events at each stage
* 10. Agent retries the operation → passes (no longer blocked)
*
* Security invariants:
* - displayCode never reaches the LLM (stripped before directive is built)
* - Codes are one-time use (VerificationStore deletes after any verify attempt)
* - Expired challenges are rejected with distinct VERIFICATION_EXPIRED events
* - Challenge IDs are validated as UUID v4 before store lookup (anti-enumeration)
* - Failed attempts are rate-limited globally (anti-brute-force)
* - All verification events are logged with granular types for monitoring
*
* Part of the Agentic Loop Completion (Epic #380).
*
* @since v2.0.0
*/
import { logger } from '../../utils/logger.js';
import { SecurityMonitor } from '../../security/securityMonitor.js';
import { matchesPattern } from '../../utils/patternMatcher.js';
import { determineSafetyTier, createVerificationChallenge, DEFAULT_SAFETY_CONFIG, showVerificationDialog, } from './safetyTierService.js';
import { getAutonomyRiskThresholds, getAutonomyMaxStepsDefault, } from '../../config/autonomy-config.js';
/**
* Default autonomy configuration
*
* Used when an agent doesn't specify autonomy settings.
* Conservative defaults prioritize safety over speed.
*
* Note: maxAutonomousSteps uses a getter to support env-var overrides
* (Issue #390). The static value here serves as the baseline; callers
* should prefer mergeWithDefaults() which reads the live config.
*/
export const DEFAULT_AUTONOMY_CONFIG = {
riskTolerance: 'moderate',
maxAutonomousSteps: 10,
requiresApproval: [],
autoApprove: [],
verificationTimeoutMinutes: 5,
};
/**
* Lightweight in-memory tracker for autonomy evaluation patterns.
* Issue #391: Provides observability into agent continue/pause decisions.
*/
class AutonomyMetricsTracker {
_totalEvaluations = 0;
_continueCount = 0;
_pauseCount = 0;
_pauseReasons = {};
_dangerZoneTriggered = 0;
_verificationRequired = 0;
_pauseStepCounts = [];
static MAX_STEP_COUNTS = 1000;
static LOG_INTERVAL = 50;
recordContinue() {
this._totalEvaluations++;
this._continueCount++;
this.maybeLogSnapshot();
}
recordPause(reason, stepCount) {
this._totalEvaluations++;
this._pauseCount++;
this._pauseReasons[reason] = (this._pauseReasons[reason] || 0) + 1;
this._pauseStepCounts.push(stepCount);
if (this._pauseStepCounts.length > AutonomyMetricsTracker.MAX_STEP_COUNTS) {
this._pauseStepCounts.shift();
}
this.maybeLogSnapshot();
}
recordDangerZone() {
this._dangerZoneTriggered++;
}
recordVerification() {
this._verificationRequired++;
}
getSnapshot() {
const avgStepCount = this._pauseStepCounts.length > 0
? Math.round(this._pauseStepCounts.reduce((a, b) => a + b, 0) / this._pauseStepCounts.length)
: 0;
return {
totalEvaluations: this._totalEvaluations,
continueCount: this._continueCount,
pauseCount: this._pauseCount,
pauseReasons: { ...this._pauseReasons },
dangerZoneTriggered: this._dangerZoneTriggered,
verificationRequired: this._verificationRequired,
averageStepCountAtPause: avgStepCount,
};
}
/** Reset (for testing). */
reset() {
this._totalEvaluations = 0;
this._continueCount = 0;
this._pauseCount = 0;
this._pauseReasons = {};
this._dangerZoneTriggered = 0;
this._verificationRequired = 0;
this._pauseStepCounts = [];
}
maybeLogSnapshot() {
if (this._totalEvaluations > 0 && this._totalEvaluations % AutonomyMetricsTracker.LOG_INTERVAL === 0) {
logger.info('Autonomy evaluation metrics snapshot', {
...this.getSnapshot(),
});
}
}
}
/** Module-level metrics instance (Issue #391) */
const autonomyMetrics = new AutonomyMetricsTracker();
/**
* Get the current autonomy evaluation metrics snapshot.
* Issue #391: Programmatic access for monitoring/diagnostics.
*/
export function getAutonomyMetrics() {
return autonomyMetrics.getSnapshot();
}
/**
* Reset autonomy metrics (for testing only).
* @internal
*/
export function resetAutonomyMetrics() {
autonomyMetrics.reset();
}
/**
* Sanitize a risk score to a valid 0-100 number.
*
* Handles NaN, non-number types, Infinity, and out-of-range values with
* appropriate warning logs. Always returns a concrete number in [0, 100]
* suitable for threshold comparison and safety tier evaluation.
*
* @param score - The raw risk score to sanitize (may be any numeric edge case)
* @param agentName - Agent name for contextual log messages
* @returns A clamped, finite number in the range [0, 100]
*/
function sanitizeRiskScore(score, agentName) {
if (typeof score !== 'number' || Number.isNaN(score)) {
logger.warn('Invalid risk score (NaN or non-number), treating as 0', {
originalScore: score,
agentName,
});
return 0;
}
if (!Number.isFinite(score)) {
logger.warn('Infinite risk score, clamping to range boundary', {
originalScore: score,
agentName,
});
return score > 0 ? 100 : 0;
}
if (score < 0 || score > 100) {
logger.warn('Risk score out of range, clamping to 0-100', {
originalScore: score,
agentName,
});
return Math.max(0, Math.min(100, score));
}
return score;
}
/**
* Store a verification code server-side and show it to the human via OS dialog.
* The display code is intentionally NOT returned to the LLM.
*
* Issue #142: Danger zone verification flow
*/
function storeAndDisplayChallenge(challenge, context) {
if (!challenge.displayCode)
return;
// Store server-side for later verification
if (context.verificationStore) {
context.verificationStore.set(challenge.challengeId, {
code: challenge.displayCode,
expiresAt: new Date(challenge.expiresAt).getTime(),
reason: challenge.reason,
});
}
// Show to human via OS-native dialog (fire-and-forget, non-blocking for evaluation)
try {
showVerificationDialog(challenge.displayCode, challenge.reason, { title: 'DollhouseMCP - Verification Required', icon: 'warning' });
}
catch (error) {
logger.warn('Failed to show verification dialog', {
error: error instanceof Error ? error.message : String(error),
challengeId: challenge.challengeId,
});
}
}
/**
* Evaluate whether an agent should continue autonomously or pause
*
* This is the main entry point for autonomy decisions. Call this after
* each step to determine if the LLM can proceed or must wait for
* human approval.
*
* @param context - The autonomy evaluation context
* @returns AutonomyDirective indicating continue or pause
*/
export function evaluateAutonomy(context) {
const config = mergeWithDefaults(context.autonomyConfig);
const factors = [];
logger.debug('Evaluating autonomy', {
agentName: context.agentName,
stepCount: context.stepCount,
outcome: context.currentStepOutcome,
nextActionHint: context.nextActionHint,
});
// Early validation: sanitize risk score before any checks consume it
if (context.riskScore !== undefined) {
context.riskScore = sanitizeRiskScore(context.riskScore, context.agentName);
}
// Check 1: Step count limit
const stepLimitResult = checkStepLimit(context.stepCount, config.maxAutonomousSteps);
if (stepLimitResult) {
factors.push(stepLimitResult.factor);
if (!stepLimitResult.continue) {
autonomyMetrics.recordPause(stepLimitResult.reason || 'step_limit', context.stepCount);
return buildDirective(false, stepLimitResult.reason, factors, {
stepsRemaining: 0,
});
}
}
// Check 2: Current step outcome
if (context.currentStepOutcome === 'failure') {
factors.push('Previous step failed');
autonomyMetrics.recordPause('Previous step failed - human review recommended', context.stepCount);
return buildDirective(false, 'Previous step failed - human review recommended', factors);
}
// Check 3: Pattern matching for next action
if (context.nextActionHint) {
const patternResult = checkActionPatterns(context.nextActionHint, config.requiresApproval, config.autoApprove);
factors.push(...patternResult.factors);
if (!patternResult.continue) {
autonomyMetrics.recordPause(patternResult.reason || 'pattern_match', context.stepCount);
return buildDirective(false, patternResult.reason, factors);
}
}
// Check 4: Safety tier evaluation
if (context.nextActionHint || context.riskScore !== undefined) {
const safetyResult = checkSafetyTier(context.nextActionHint || context.currentStepDescription, context.riskScore || 0, config.riskTolerance, config.verificationTimeoutMinutes);
factors.push(...safetyResult.factors);
if (safetyResult.stopped) {
// Issue #142: Create verification challenge for danger zone unblocking
const dzChallenge = createVerificationChallenge(`Danger zone verification: ${(context.nextActionHint || context.currentStepDescription).substring(0, 100)}`, 'display_code', config.verificationTimeoutMinutes);
// Store the code server-side and show via OS dialog (Issue #142)
storeAndDisplayChallenge(dzChallenge, context);
// Programmatic enforcement: block the agent from further execution
// This prevents a compromised LLM from ignoring the danger zone warning
// Issue #402: Use DI-injected enforcer instead of singleton
context.dangerZoneEnforcer?.block(context.agentName, safetyResult.reason || 'Danger zone operation detected', safetyResult.factors, dzChallenge.challengeId, {
stepNumber: context.stepCount,
currentStepDescription: context.currentStepDescription,
currentStepOutcome: context.currentStepOutcome,
nextActionHint: context.nextActionHint,
riskScore: context.riskScore,
goalDescription: context.goalDescription,
goalId: context.goalId,
safetyFactors: factors,
});
SecurityMonitor.logSecurityEvent({
type: 'DANGER_ZONE_TRIGGERED',
severity: 'HIGH',
source: 'AutonomyEvaluator.evaluateAutonomy',
details: `Agent '${context.agentName}' blocked: danger zone verification required — ${safetyResult.reason ?? 'danger zone operation detected'}`,
additionalData: {
agentName: context.agentName,
factors,
nextActionHint: context.nextActionHint,
stepCount: context.stepCount,
riskScore: context.riskScore,
currentStepDescription: context.currentStepDescription,
goalDescription: context.goalDescription?.substring(0, 200),
challengeId: dzChallenge.challengeId,
},
});
autonomyMetrics.recordPause(safetyResult.reason || 'danger_zone', context.stepCount);
autonomyMetrics.recordDangerZone();
autonomyMetrics.recordVerification();
return buildDirective(false, safetyResult.reason, factors, {
stopped: true,
nextStepRisk: 'danger_zone',
// Issue #142: Include verification info (without displayCode) so LLM knows how to unblock
verification: {
verificationId: dzChallenge.challengeId,
prompt: dzChallenge.prompt,
// displayCode intentionally omitted — shown via OS dialog only
challengeType: dzChallenge.challengeType,
expiresAt: dzChallenge.expiresAt,
},
});
}
if (safetyResult.verification) {
// Issue #142: Store code server-side, show via OS dialog, strip displayCode
storeAndDisplayChallenge({
challengeId: safetyResult.verification.verificationId,
displayCode: safetyResult.verification.displayCode,
reason: `Verify action: ${(context.nextActionHint || context.currentStepDescription).substring(0, 100)}`,
expiresAt: safetyResult.verification.expiresAt,
}, context);
autonomyMetrics.recordPause(safetyResult.reason || 'verification_required', context.stepCount);
autonomyMetrics.recordVerification();
return buildDirective(false, safetyResult.reason, factors, {
verification: {
verificationId: safetyResult.verification.verificationId,
prompt: safetyResult.verification.prompt,
// displayCode intentionally omitted — shown via OS dialog only (Issue #142)
challengeType: safetyResult.verification.challengeType,
expiresAt: safetyResult.verification.expiresAt,
},
nextStepRisk: safetyResult.tier,
});
}
if (!safetyResult.continue) {
autonomyMetrics.recordPause(safetyResult.reason || 'safety_tier', context.stepCount);
return buildDirective(false, safetyResult.reason, factors, {
nextStepRisk: safetyResult.tier,
});
}
}
// Check 5: Risk score vs tolerance threshold
if (context.riskScore !== undefined) {
const thresholdResult = checkRiskThreshold(context.riskScore, config.riskTolerance);
factors.push(thresholdResult.factor);
if (!thresholdResult.continue) {
autonomyMetrics.recordPause(thresholdResult.reason || 'risk_threshold', context.stepCount);
return buildDirective(false, thresholdResult.reason, factors);
}
}
// All checks passed - continue autonomously
const stepsRemaining = config.maxAutonomousSteps > 0
? config.maxAutonomousSteps - context.stepCount - 1
: undefined;
factors.push('All autonomy checks passed');
logger.debug('Autonomy evaluation complete: continue', {
agentName: context.agentName,
stepsRemaining,
factors,
});
// Issue #391: Record metrics for continue outcome
autonomyMetrics.recordContinue();
return buildDirective(true, undefined, factors, { stepsRemaining });
}
/**
* Check if step count has reached the maximum allowed autonomous steps.
*
* @param stepCount - Current zero-based step index
* @param maxSteps - Maximum autonomous steps allowed (0 = unlimited)
* @returns StepLimitResult with continue/pause decision and descriptive factor,
* or null if maxSteps is 0 (unlimited) — though in practice always returns a result
*/
function checkStepLimit(stepCount, maxSteps) {
if (maxSteps === 0) {
return { continue: true, factor: 'Unlimited autonomous steps configured' };
}
if (stepCount >= maxSteps) {
return {
continue: false,
reason: `Maximum autonomous steps reached (${maxSteps})`,
factor: `Step ${stepCount + 1} exceeds maxAutonomousSteps=${maxSteps}`,
};
}
return {
continue: true,
factor: `Step ${stepCount + 1} of ${maxSteps} autonomous steps`,
};
}
/**
* Check an action string against requiresApproval and autoApprove glob patterns.
*
* requiresApproval patterns take precedence over autoApprove patterns.
* If no pattern matches, the action is allowed by default.
*
* @param action - The proposed next action string (e.g. "delete user data")
* @param requiresApproval - Glob patterns that force a pause (e.g. ["*delete*"])
* @param autoApprove - Glob patterns that explicitly allow continuation (e.g. ["read*"])
* @returns ActionPatternResult with continue/pause decision and matching factor strings
*/
function checkActionPatterns(action, requiresApproval, autoApprove) {
const factors = [];
const actionLower = action.toLowerCase();
// requiresApproval takes precedence
for (const pattern of requiresApproval) {
if (matchesPattern(actionLower, pattern)) {
factors.push(`Action matches requiresApproval pattern: ${pattern}`);
return {
continue: false,
reason: `Action requires approval: matches pattern "${pattern}"`,
factors,
};
}
}
// Check autoApprove patterns
for (const pattern of autoApprove) {
if (matchesPattern(actionLower, pattern)) {
factors.push(`Action matches autoApprove pattern: ${pattern}`);
return { continue: true, factors };
}
}
factors.push('No pattern match - using default behavior');
return { continue: true, factors };
}
// matchesPattern is imported from '../../utils/patternMatcher.js'
/**
* Evaluate the safety tier for a proposed action and determine if it can proceed.
*
* Calls `determineSafetyTier()` from the safety package and maps the result
* to a continue/pause decision. Tiers escalate: advisory → confirm → verify → danger_zone.
*
* Issue #389: Wraps determineSafetyTier() in try-catch. If the safety package throws,
* logs the error and returns a conservative "pause" result (fail-safe: if we can't
* evaluate safety, don't continue).
*
* @param action - Description of the proposed next action
* @param riskScore - Numeric risk score (0-100, already sanitized)
* @param riskTolerance - Agent's risk tolerance level ("conservative" | "moderate" | "aggressive")
* @param verificationTimeoutMinutes - Expiry time for verification challenges (default: 5)
* @returns SafetyTierResult with continue/pause decision, tier info, and optional verification challenge
*/
function checkSafetyTier(action, riskScore, riskTolerance, verificationTimeoutMinutes = 5) {
const factors = [];
// Determine safety tier (Issue #389: fail-safe on errors)
let tierResult;
try {
tierResult = determineSafetyTier(riskScore, [], // No security warnings for step evaluation
action, DEFAULT_SAFETY_CONFIG);
}
catch (error) {
const errorMsg = error instanceof Error ? error.message : String(error);
logger.error('Safety tier evaluation failed — returning conservative pause', {
error: errorMsg,
action: action.substring(0, 200),
riskScore,
riskTolerance,
});
SecurityMonitor.logSecurityEvent({
type: 'SAFETY_EVALUATION_FAILURE',
severity: 'HIGH',
source: 'AutonomyEvaluator.checkSafetyTier',
details: `determineSafetyTier() threw: ${errorMsg}`,
additionalData: { action: action.substring(0, 200), riskScore, riskTolerance },
});
factors.push(`Safety tier evaluation failed: ${errorMsg}`);
return {
continue: false,
reason: 'Safety evaluation failed — pausing for human review',
factors,
};
}
factors.push(`Safety tier: ${tierResult.tier}`);
factors.push(...tierResult.factors.map((f) => ` - ${f}`));
switch (tierResult.tier) {
case 'advisory':
return { continue: true, factors, tier: 'advisory' };
case 'confirm':
// For moderate+ tolerance, auto-approve confirm tier
if (riskTolerance === 'aggressive') {
factors.push('Aggressive risk tolerance: auto-approving CONFIRM tier');
return { continue: true, factors, tier: 'confirm' };
}
return {
continue: false,
reason: 'Action requires confirmation before proceeding',
factors,
tier: 'confirm',
};
case 'verify': {
// Create verification challenge
const challenge = createVerificationChallenge(`Verify action: ${action.substring(0, 100)}`, 'display_code', verificationTimeoutMinutes);
return {
continue: false,
reason: 'Action requires verification before proceeding',
factors,
tier: 'verify',
verification: {
verificationId: challenge.challengeId,
prompt: challenge.prompt,
displayCode: challenge.displayCode,
challengeType: challenge.challengeType,
expiresAt: challenge.expiresAt,
},
};
}
case 'danger_zone':
return {
continue: false,
reason: 'Action blocked: danger zone operation detected',
factors,
tier: 'danger_zone',
stopped: true,
};
default:
return { continue: true, factors, tier: tierResult.tier };
}
}
/**
* Check whether a risk score exceeds the threshold for the given tolerance level.
*
* Uses strict greater-than comparison: a score equal to the threshold is allowed.
* Issue #390: Thresholds are now configurable via environment variables.
*
* @param riskScore - Numeric risk score (0-100, already sanitized)
* @param riskTolerance - Agent's risk tolerance level ("conservative" | "moderate" | "aggressive")
* @returns RiskThresholdResult with continue/pause decision and descriptive factor
*/
function checkRiskThreshold(riskScore, riskTolerance) {
const thresholds = getAutonomyRiskThresholds();
const threshold = thresholds[riskTolerance] ?? thresholds.moderate;
if (riskScore > threshold) {
return {
continue: false,
reason: `Risk score (${riskScore}) exceeds ${riskTolerance} threshold (${threshold})`,
factor: `Risk ${riskScore} > threshold ${threshold} for ${riskTolerance} tolerance`,
};
}
return {
continue: true,
factor: `Risk ${riskScore} within ${riskTolerance} threshold (${threshold})`,
};
}
/**
* Merge a partial user-provided autonomy config with defaults.
*
* Missing fields fall back to DEFAULT_AUTONOMY_CONFIG values, except
* maxAutonomousSteps which reads the env-configurable default (Issue #390).
*
* @param config - Optional partial autonomy config from the agent definition
* @returns Fully populated config with all fields guaranteed present
*/
function mergeWithDefaults(config) {
return {
riskTolerance: config?.riskTolerance ?? DEFAULT_AUTONOMY_CONFIG.riskTolerance,
maxAutonomousSteps: config?.maxAutonomousSteps ?? getAutonomyMaxStepsDefault(),
requiresApproval: config?.requiresApproval ?? DEFAULT_AUTONOMY_CONFIG.requiresApproval,
autoApprove: config?.autoApprove ?? DEFAULT_AUTONOMY_CONFIG.autoApprove,
verificationTimeoutMinutes: config?.verificationTimeoutMinutes ?? DEFAULT_AUTONOMY_CONFIG.verificationTimeoutMinutes,
};
}
/**
* Build a structured AutonomyDirective from components.
*
* @param shouldContinue - Whether the agent may continue autonomously
* @param reason - Human-readable explanation when paused (undefined when continuing)
* @param factors - Array of descriptive strings explaining each check's contribution
* @param extras - Optional additional fields (stepsRemaining, stopped, verification, nextStepRisk)
* @returns Complete AutonomyDirective ready for the LLM handoff
*/
function buildDirective(shouldContinue, reason, factors, extras) {
return {
continue: shouldContinue,
reason,
factors,
...extras,
};
}
/**
* Quick check if an action would be auto-approved given an autonomy config.
*
* Utility function for pre-checking actions before execution.
* Does NOT evaluate safety tiers or risk scores — only pattern matching.
*
* @param action - The proposed action string to check
* @param config - Optional autonomy config (uses defaults if not provided)
* @returns true if the action matches an autoApprove pattern or the agent
* uses aggressive tolerance; false if it matches requiresApproval or no match
*/
export function wouldAutoApprove(action, config) {
const mergedConfig = mergeWithDefaults(config);
const actionLower = action.toLowerCase();
// Check requiresApproval first (takes precedence)
for (const pattern of mergedConfig.requiresApproval) {
if (matchesPattern(actionLower, pattern)) {
return false;
}
}
// Check autoApprove
for (const pattern of mergedConfig.autoApprove) {
if (matchesPattern(actionLower, pattern)) {
return true;
}
}
// Default behavior depends on risk tolerance
return mergedConfig.riskTolerance === 'aggressive';
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autonomyEvaluator.js","sourceRoot":"","sources":["../../../src/elements/agents/autonomyEvaluator.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Autonomy Evaluator Service\n *\n * Determines whether an agent should continue autonomously or pause\n * for human input after each step. This is the brain that enables\n * automatic continue/pause decisions in the agentic loop.\n *\n * Decision factors:\n * 1. Step count vs maxAutonomousSteps\n * 2. Next action vs requiresApproval patterns\n * 3. Safety tier (ALLOW/VERIFY/DENY)\n * 4. Risk tolerance configuration\n *\n * ## Danger Zone Verification Flow (Issue #142)\n *\n * When an agent action triggers the DANGER_ZONE or VERIFY safety tier,\n * a human-in-the-loop verification is required before the agent can proceed.\n *\n * End-to-end sequence:\n *\n *  1. Agent proposes an action (nextActionHint) during agentic loop\n *  2. evaluateAutonomy() calls checkSafetyTier() → returns DANGER_ZONE or VERIFY\n *  3. createVerificationChallenge() generates a challenge with:\n *     - challengeId (UUID v4 via crypto.randomUUID)\n *     - displayCode (human-readable code, e.g. \"ABC123\")\n *     - expiresAt (configurable, default 5 minutes)\n *  4. storeAndDisplayChallenge():\n *     a. Stores {code, expiresAt, reason} in VerificationStore (server-side, one-time use)\n *     b. Shows displayCode to human via OS-native dialog (AppleScript/zenity/PowerShell)\n *     c. displayCode is NEVER included in the LLM-facing directive\n *  5. For DANGER_ZONE: DangerZoneEnforcer.block() programmatically blocks the agent\n *     with verificationId=challengeId (file-backed, survives restarts)\n *  6. LLM receives directive with verification.verificationId but NO displayCode\n *     plus actionable guidance: \"Use verify_challenge { challenge_id, code }\"\n *  7. Human reads code from OS dialog, tells LLM\n *  8. LLM calls verify_challenge MCP-AQL operation\n *  9. MCPAQLHandler verify handler:\n *     a. Validates UUID v4 format (rejects invalid IDs before store lookup)\n *     b. Checks rate limit (max 10 failures per 60s sliding window)\n *     c. Distinguishes expired (VERIFICATION_EXPIRED) from wrong code (VERIFICATION_FAILED)\n *     d. On success: finds blocked agent by challengeId → DangerZoneEnforcer.unblock()\n *     e. Logs granular security events at each stage\n * 10. Agent retries the operation → passes (no longer blocked)\n *\n * Security invariants:\n * - displayCode never reaches the LLM (stripped before directive is built)\n * - Codes are one-time use (VerificationStore del