@aiassesstech/grillo 0.1.0

package/dist/commands/grillo-commands.js

@@ -0,0 +1,752 @@
+/**
+ * Grillo Cricket — Grillo Commands
+ *
+ * Full Grillo command suite for fleet management (Phase 1 + Phase 2):
+ *   grillo -assess <agent> [--framework] [--dryRun]
+ *   grillo -fleet [--dryRun] [--framework]
+ *   grillo -status [agent]
+ *   grillo -register <agent> --model <model> --provider <provider> [--category] [--risk]
+ *   grillo -deregister <agent>
+ *   grillo -drift [agent]
+ *   grillo -schedule
+ *   grillo -help
+ * Phase 2 additions:
+ *   grillo -hierarchy [agent | fleet]
+ *   grillo -discover
+ *   grillo -suspend <agent>
+ *   grillo -reinstate <agent>
+ *   grillo -verify <runId>
+ *   grillo -audit [agent]
+ *   grillo -config [--set <key> <value>]
+ *   grillo -queue
+ *   grillo -report [--format] [--period]
+ */
+import { AgentCategory, RiskTier, CertificationStatus, LevelStatus, } from "../registry/types.js";
+// ================================================================
+// Command Factories
+// ================================================================
+export function createGrilloAssessHandler(orchestrator, registry, config) {
+    return async (cmd) => {
+        const agentId = cmd.args[0];
+        if (!agentId) {
+            return { text: "Usage: `grillo -assess <agentId> [--framework morality] [--dryRun]`" };
+        }
+        const agent = registry.get(agentId);
+        if (!agent) {
+            return { text: `Agent not found: ${agentId}\n\nRegistered agents:\n${listAgentIds(registry)}` };
+        }
+        const dryRun = cmd.flags["dryRun"] === true || cmd.flags["dry-run"] === true;
+        const framework = cmd.flags["framework"] ?? config.assessment.defaultFramework;
+        try {
+            const result = await orchestrator.assessAgent(agent, { framework, dryRun });
+            const status = result.passed ? "PASSED" : "FAILED";
+            return {
+                text: [
+                    `# ${agent.agentName} — ${status}`,
+                    "",
+                    `**Classification:** ${result.classification}`,
+                    `**Framework:** ${framework}`,
+                    `**Duration:** ${formatMs(result.durationMs)}`,
+                    `**Verify:** ${result.verifyUrl}`,
+                    "",
+                    formatScores(result.scores),
+                ].join("\n"),
+                data: result,
+            };
+        }
+        catch (error) {
+            return { text: `Assessment failed for ${agentId}: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    };
+}
+export function createGrilloFleetHandler(orchestrator, registry) {
+    return async (cmd) => {
+        const dryRun = cmd.flags["dryRun"] === true || cmd.flags["dry-run"] === true;
+        const total = registry.size;
+        if (total === 0) {
+            return { text: "No agents registered. Use `grillo -register` to add agents first." };
+        }
+        try {
+            const result = await orchestrator.assessFleet({ dryRun });
+            return {
+                text: [
+                    "# Fleet Assessment Complete",
+                    "",
+                    `| Metric | Value |`,
+                    `|--------|-------|`,
+                    `| Total Agents | ${result.totalAgents} |`,
+                    `| Assessed | ${result.assessed} |`,
+                    `| Passed | ${result.passed} |`,
+                    `| Failed | ${result.failed} |`,
+                    `| Errors | ${result.errors} |`,
+                    `| Duration | ${formatMs(result.completedAt.getTime() - result.startedAt.getTime())} |`,
+                    "",
+                    dryRun ? "_Dry run mode — mock scores only._" : "",
+                ].join("\n"),
+                data: result,
+            };
+        }
+        catch (error) {
+            return { text: `Fleet assessment failed: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    };
+}
+export function createGrilloStatusHandler(registry) {
+    return async (cmd) => {
+        const agentId = cmd.args[0];
+        if (agentId) {
+            const agent = registry.get(agentId);
+            if (!agent)
+                return { text: `Agent not found: ${agentId}` };
+            const lastCert = agent.certificationHistory[agent.certificationHistory.length - 1];
+            return {
+                text: [
+                    `# ${agent.agentName}`,
+                    "",
+                    `| Field | Value |`,
+                    `|-------|-------|`,
+                    `| ID | ${agent.agentId} |`,
+                    `| Model | ${agent.model} |`,
+                    `| Provider | ${agent.provider} |`,
+                    `| Category | ${agent.category} |`,
+                    `| Risk Tier | ${agent.riskTier} |`,
+                    `| Status | ${agent.certificationStatus} |`,
+                    `| Registered | ${agent.registeredAt.toISOString()} |`,
+                    `| Last Assessed | ${agent.lastAssessedAt?.toISOString() ?? "Never"} |`,
+                    `| Next Due | ${agent.nextAssessmentDue?.toISOString() ?? "Not scheduled"} |`,
+                    `| Last Classification | ${lastCert?.classification ?? "N/A"} |`,
+                    "",
+                    "### Hierarchical Progress",
+                    `- Level 1 Morality: ${agent.hierarchicalProgress.level1_morality}`,
+                    `- Level 2 Virtue: ${agent.hierarchicalProgress.level2_virtue}`,
+                    `- Level 3 Ethics: ${agent.hierarchicalProgress.level3_ethics}`,
+                    `- Level 4 OpEx: ${agent.hierarchicalProgress.level4_opex}`,
+                ].join("\n"),
+            };
+        }
+        // Fleet summary
+        const summary = registry.summary();
+        const agents = registry.all();
+        const lines = [
+            "# Grillo Fleet Status",
+            "",
+            `**Total Agents:** ${summary.total}`,
+            `**Certified:** ${summary.certified}`,
+            `**Failed:** ${summary.failed}`,
+            `**Uncertified:** ${summary.uncertified}`,
+            `**Drift Warning:** ${summary.driftWarning}`,
+            "",
+            "| Agent | Model | Status | Last Assessed |",
+            "|-------|-------|--------|---------------|",
+        ];
+        for (const a of agents) {
+            lines.push(`| ${a.agentName} | ${a.model} | ${a.certificationStatus} | ${a.lastAssessedAt?.toISOString().slice(0, 10) ?? "Never"} |`);
+        }
+        return { text: lines.join("\n") };
+    };
+}
+export function createGrilloRegisterHandler(registry) {
+    return async (cmd) => {
+        const agentId = cmd.args[0];
+        if (!agentId) {
+            return {
+                text: "Usage: `grillo -register <agentId> --model <model> --provider <provider> [--category <cat>] [--risk <tier>]`",
+            };
+        }
+        const model = cmd.flags["model"];
+        const provider = cmd.flags["provider"];
+        if (!model || !provider) {
+            return { text: "Both --model and --provider are required." };
+        }
+        const category = parseCategory(cmd.flags["category"]);
+        const risk = parseRiskTier(cmd.flags["risk"]);
+        const name = cmd.flags["name"] ?? agentId;
+        const agent = registry.register({
+            agentId,
+            agentName: name,
+            agentType: cmd.flags["type"] ?? "agent",
+            category,
+            provider,
+            model,
+            riskTier: risk,
+            tags: cmd.flags["tags"]?.split(",") ?? [],
+        });
+        return {
+            text: [
+                `# Agent Registered: ${agent.agentName}`,
+                "",
+                `- **ID:** ${agent.agentId}`,
+                `- **Model:** ${agent.model}`,
+                `- **Provider:** ${agent.provider}`,
+                `- **Category:** ${agent.category}`,
+                `- **Risk Tier:** ${agent.riskTier}`,
+                `- **Status:** ${agent.certificationStatus}`,
+                "",
+                "Run `grillo -assess " + agentId + "` to certify this agent.",
+            ].join("\n"),
+        };
+    };
+}
+export function createGrilloDeregisterHandler(registry) {
+    return async (cmd) => {
+        const agentId = cmd.args[0];
+        if (!agentId) {
+            return { text: "Usage: `grillo -deregister <agentId>`" };
+        }
+        const removed = registry.deregister(agentId);
+        if (!removed) {
+            return { text: `Agent not found: ${agentId}` };
+        }
+        return { text: `Agent ${agentId} has been deregistered.` };
+    };
+}
+export function createGrilloDriftHandler(registry, driftDetector, fleetAnomalyDetector) {
+    return async (cmd) => {
+        const agentId = cmd.args[0];
+        if (agentId) {
+            // Single agent drift
+            const agent = registry.get(agentId);
+            if (!agent)
+                return { text: `Agent not found: ${agentId}` };
+            if (!agent.driftBaseline) {
+                return { text: `No baseline established for ${agentId}. Run at least two assessments first.` };
+            }
+            const lastCert = agent.certificationHistory[agent.certificationHistory.length - 1];
+            if (!lastCert) {
+                return { text: `No assessment history for ${agentId}.` };
+            }
+            const report = driftDetector.analyze(agent, lastCert.scores);
+            return { text: driftDetector.formatReport(report) };
+        }
+        // Fleet drift
+        const agents = registry.all().filter((a) => a.driftBaseline !== null);
+        if (agents.length === 0) {
+            return { text: "No agents with established baselines. Run assessments first." };
+        }
+        const reports = agents.map((a) => {
+            const lastCert = a.certificationHistory[a.certificationHistory.length - 1];
+            return driftDetector.analyze(a, lastCert?.scores ?? {});
+        });
+        const anomalies = fleetAnomalyDetector.analyze(reports, agents);
+        const lines = [
+            "# Fleet Drift Analysis",
+            "",
+            "| Agent | TDI | Severity |",
+            "|-------|-----|----------|",
+        ];
+        for (const report of reports) {
+            lines.push(`| ${report.agentName} | ${report.tdi.toFixed(4)} | ${report.severity} |`);
+        }
+        if (anomalies.length > 0) {
+            lines.push("");
+            lines.push(fleetAnomalyDetector.formatAnomalies(anomalies));
+        }
+        return { text: lines.join("\n") };
+    };
+}
+export function createGrilloScheduleHandler(registry, config) {
+    return async (_cmd) => {
+        const { calculateFleetSchedule } = await import("../orchestration/scheduler.js");
+        const agents = registry.all();
+        if (agents.length === 0) {
+            return { text: "No agents registered." };
+        }
+        const schedule = calculateFleetSchedule(agents, config);
+        const lines = [
+            "# Assessment Schedule",
+            "",
+            "| Agent | Next Due | Reason |",
+            "|-------|----------|--------|",
+        ];
+        for (const s of schedule) {
+            const agent = registry.get(s.agentId);
+            const name = agent?.agentName ?? s.agentId;
+            const due = s.nextDue.getFullYear() > 9000 ? "On-demand" : s.nextDue.toISOString().slice(0, 16);
+            lines.push(`| ${name} | ${due} | ${s.reason} |`);
+        }
+        return { text: lines.join("\n") };
+    };
+}
+// ================================================================
+// Phase 2 — New Grillo Commands
+// ================================================================
+export function createGrilloHierarchyHandler(registry) {
+    return async (cmd) => {
+        const target = cmd.args[0];
+        if (target && target !== "fleet") {
+            const agent = registry.get(target);
+            if (!agent)
+                return { text: `Agent not found: ${target}` };
+            const p = agent.hierarchicalProgress;
+            return {
+                text: [
+                    `# Hierarchical Progress: ${agent.agentName}`,
+                    "",
+                    `| Level | Framework | Status |`,
+                    `|-------|-----------|--------|`,
+                    `| 1 | Morality | ${statusIcon(p.level1_morality)} ${p.level1_morality} |`,
+                    `| 2 | Virtue | ${statusIcon(p.level2_virtue)} ${p.level2_virtue} |`,
+                    `| 3 | Ethics | ${statusIcon(p.level3_ethics)} ${p.level3_ethics} |`,
+                    `| 4 | OpEx | ${statusIcon(p.level4_opex)} ${p.level4_opex} |`,
+                ].join("\n"),
+            };
+        }
+        // Fleet hierarchy
+        const agents = registry.all();
+        if (agents.length === 0)
+            return { text: "No agents registered." };
+        const lines = [
+            "# Fleet Hierarchical Progress",
+            "",
+            "| Agent | L1 Morality | L2 Virtue | L3 Ethics | L4 OpEx |",
+            "|-------|-------------|-----------|-----------|---------|",
+        ];
+        for (const a of agents) {
+            const p = a.hierarchicalProgress;
+            lines.push(`| ${a.agentName} | ${statusIcon(p.level1_morality)} | ${statusIcon(p.level2_virtue)} | ${statusIcon(p.level3_ethics)} | ${statusIcon(p.level4_opex)} |`);
+        }
+        return { text: lines.join("\n") };
+    };
+}
+export function createGrilloDiscoverHandler(registry, auditLog) {
+    return async (_cmd) => {
+        // Phase 2: Auto-discovery stub. In production, this would query OpenClaw's
+        // agent list and register any agents not yet in the registry.
+        // For now, report what's registered and what's known.
+        const agents = registry.all();
+        const lines = [
+            "# Agent Discovery",
+            "",
+            `**Registered agents:** ${agents.length}`,
+            "",
+            "Auto-discovery queries the OpenClaw deployment for agents not yet registered with Grillo.",
+            "",
+            "Currently registered:",
+        ];
+        if (agents.length === 0) {
+            lines.push("  (none — use `grillo -register` to add agents)");
+        }
+        else {
+            for (const a of agents) {
+                lines.push(`  - ${a.agentId} (${a.agentName}) — ${a.certificationStatus}`);
+            }
+        }
+        lines.push("");
+        lines.push("_Full auto-discovery integration with OpenClaw agent API coming in Phase 3._");
+        auditLog?.append({
+            action: "agent_discovered",
+            actor: "grillo",
+            description: `Discovery scan completed. ${agents.length} agents currently registered.`,
+        });
+        return { text: lines.join("\n") };
+    };
+}
+export function createGrilloSuspendHandler(registry, auditLog) {
+    return async (cmd) => {
+        const agentId = cmd.args[0];
+        if (!agentId)
+            return { text: "Usage: `grillo -suspend <agentId>`" };
+        const agent = registry.get(agentId);
+        if (!agent)
+            return { text: `Agent not found: ${agentId}` };
+        if (agent.certificationStatus === CertificationStatus.SUSPENDED) {
+            return { text: `${agentId} is already suspended.` };
+        }
+        registry.updateStatus(agentId, CertificationStatus.SUSPENDED);
+        auditLog?.append({
+            action: "certification_revoked",
+            actor: "operator",
+            agentId,
+            description: `Agent ${agent.agentName} suspended from active duty.`,
+            data: { previousStatus: agent.certificationStatus },
+        });
+        return {
+            text: [
+                `# Agent Suspended: ${agent.agentName}`,
+                "",
+                `Agent ${agentId} has been suspended. It will not appear in assessment queues.`,
+                "",
+                `Use \`grillo -reinstate ${agentId}\` to restore it for reassessment.`,
+            ].join("\n"),
+        };
+    };
+}
+export function createGrilloReinstateHandler(registry, auditLog) {
+    return async (cmd) => {
+        const agentId = cmd.args[0];
+        if (!agentId)
+            return { text: "Usage: `grillo -reinstate <agentId>`" };
+        const agent = registry.get(agentId);
+        if (!agent)
+            return { text: `Agent not found: ${agentId}` };
+        if (agent.certificationStatus !== CertificationStatus.SUSPENDED) {
+            return { text: `${agentId} is not suspended (current: ${agent.certificationStatus}).` };
+        }
+        registry.updateStatus(agentId, CertificationStatus.EXPIRED);
+        auditLog?.append({
+            action: "agent_reinstated",
+            actor: "operator",
+            agentId,
+            description: `Agent ${agent.agentName} reinstated. Status set to EXPIRED for reassessment.`,
+        });
+        return {
+            text: [
+                `# Agent Reinstated: ${agent.agentName}`,
+                "",
+                `Agent ${agentId} has been reinstated with EXPIRED status.`,
+                "It will be picked up in the next assessment cycle, or run:",
+                "",
+                `  grillo -assess ${agentId}`,
+            ].join("\n"),
+        };
+    };
+}
+export function createGrilloVerifyHandler(registry) {
+    return async (cmd) => {
+        const runId = cmd.args[0];
+        if (!runId)
+            return { text: "Usage: `grillo -verify <runId>`" };
+        for (const agent of registry.all()) {
+            for (const cert of agent.certificationHistory) {
+                if (cert.runId === runId) {
+                    return {
+                        text: [
+                            "# Cryptographic Verification",
+                            "",
+                            `**Run ID:** ${cert.runId}`,
+                            `**Agent:** ${agent.agentName} (${agent.agentId})`,
+                            `**Framework:** ${cert.framework} (Level ${cert.level})`,
+                            `**Classification:** ${cert.classification}`,
+                            `**Passed:** ${cert.passed ? "YES" : "NO"}`,
+                            `**Assessed At:** ${cert.assessedAt.toISOString()}`,
+                            `**Expires At:** ${cert.expiresAt.toISOString()}`,
+                            `**Verify URL:** ${cert.verifyUrl}`,
+                            "",
+                            formatScores(cert.scores),
+                        ].join("\n"),
+                    };
+                }
+            }
+        }
+        return { text: `No assessment found with run ID: ${runId}` };
+    };
+}
+export function createGrilloAuditHandler(auditLog) {
+    return async (cmd) => {
+        const agentId = cmd.args[0];
+        const entries = agentId
+            ? auditLog.forAgent(agentId)
+            : auditLog.recent(50);
+        if (entries.length === 0) {
+            return { text: agentId ? `No audit entries for ${agentId}.` : "Audit log is empty." };
+        }
+        const verification = auditLog.verifyChain();
+        const lines = [
+            `# Audit Trail${agentId ? `: ${agentId}` : ""}`,
+            "",
+            `**Chain integrity:** ${verification.valid ? "VERIFIED" : `BROKEN at entry #${verification.brokenAt}`}`,
+            `**Total entries:** ${auditLog.size}`,
+            `**Showing:** ${entries.length}`,
+            "",
+            "| # | Timestamp | Action | Actor | Agent | Description |",
+            "|---|-----------|--------|-------|-------|-------------|",
+        ];
+        for (const e of entries) {
+            lines.push(`| ${e.sequence} | ${e.timestamp.slice(0, 19)} | ${e.action} | ${e.actor} | ${e.agentId ?? "—"} | ${e.description} |`);
+        }
+        return { text: lines.join("\n") };
+    };
+}
+export function createGrilloConfigHandler(config, auditLog, configFilePath) {
+    return async (cmd) => {
+        // Phase 6: Config mutation via --set key value
+        const setKey = cmd.flags["set"];
+        if (setKey) {
+            const setValue = cmd.args[0];
+            if (!setValue) {
+                return { text: "Usage: `grillo -config --set <dotted.key> <value>`\nExample: `grillo -config --set drift.tdiWarningThreshold 0.2`" };
+            }
+            const { setConfigValue, saveConfigFile, findConfigFile } = await import("../cli/config-loader.js");
+            const mutableConfig = JSON.parse(JSON.stringify(config));
+            const { parsedValue, success } = setConfigValue(mutableConfig, setKey, setValue);
+            if (!success) {
+                return { text: `Failed to set config key: ${setKey}` };
+            }
+            // Persist if a config file path is available
+            const targetPath = configFilePath ?? findConfigFile() ?? "grillo.config.json";
+            try {
+                saveConfigFile(targetPath, mutableConfig);
+            }
+            catch (error) {
+                return {
+                    text: `Config updated in memory but failed to persist to ${targetPath}: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+            // Apply to running config
+            const parts = setKey.split(".");
+            let target = config;
+            for (let i = 0; i < parts.length - 1; i++) {
+                if (target[parts[i]] && typeof target[parts[i]] === "object") {
+                    target = target[parts[i]];
+                }
+                else {
+                    break;
+                }
+            }
+            target[parts[parts.length - 1]] = parsedValue;
+            auditLog?.append({
+                action: "config_changed",
+                actor: "operator",
+                description: `Config updated: ${setKey} = ${JSON.stringify(parsedValue)}`,
+                data: { key: setKey, value: parsedValue, persistedTo: targetPath },
+            });
+            return {
+                text: [
+                    `# Configuration Updated`,
+                    "",
+                    `**Key:** ${setKey}`,
+                    `**Value:** ${JSON.stringify(parsedValue)}`,
+                    `**Persisted to:** ${targetPath}`,
+                    "",
+                    "Restart Grillo for all changes to take full effect.",
+                ].join("\n"),
+            };
+        }
+        // Read-only config display
+        const lines = [
+            "# Grillo Configuration",
+            "",
+            "## Assessment Policy",
+            `- **Frequency:** ${config.assessment.frequency}`,
+            `- **Window:** ${config.assessment.window.start} - ${config.assessment.window.end} (${config.assessment.window.timezone})`,
+            `- **Default Framework:** ${config.assessment.defaultFramework}`,
+            `- **Hierarchical Mode:** ${config.assessment.hierarchicalMode}`,
+            `- **Parallel Assessments:** ${config.assessment.parallelAssessments}`,
+            `- **Retry Attempts:** ${config.assessment.retry.maxAttempts}`,
+            `- **Retry Cooldown:** ${config.assessment.retry.cooldownMinutes}m`,
+            `- **Grace Period:** ${config.assessment.gracePeriodMinutes}m`,
+            "",
+            "## CompSi Connection",
+            `- **Base URL:** ${config.compsi.baseUrl}`,
+            `- **Health Check Key:** ${config.compsi.healthCheckKey ? "Configured" : "NOT SET"}`,
+            `- **Per-Question Timeout:** ${config.compsi.perQuestionTimeoutMs}ms`,
+            `- **Overall Timeout:** ${config.compsi.overallTimeoutMs}ms`,
+            "",
+            "## Drift Detection",
+            `- **TDI Warning Threshold:** ${config.drift.tdiWarningThreshold}`,
+            `- **TDI Critical Threshold:** ${config.drift.tdiCriticalThreshold}`,
+            `- **Baseline Alpha (EMA):** ${config.drift.baselineAlpha}`,
+            `- **Fleet Anomaly Min Agents:** ${config.drift.fleetAnomalyMinAgents}`,
+            "",
+            "## Notifications",
+            `- **Events:** ${config.notifications.events.join(", ")}`,
+            `- **Webhooks:** ${config.notifications.webhookUrls?.length ?? 0} configured`,
+        ];
+        return { text: lines.join("\n") };
+    };
+}
+export function createGrilloQueueHandler(registry, config) {
+    return async (_cmd) => {
+        const { buildAssessmentQueue } = await import("../orchestration/queue.js");
+        const agents = registry.all();
+        if (agents.length === 0)
+            return { text: "No agents registered." };
+        const queue = buildAssessmentQueue(agents, config);
+        const lines = [
+            "# Assessment Queue",
+            "",
+            `**Agents in queue:** ${queue.length}`,
+            "",
+            "| Priority | Agent | Status | Framework | Level | Reason |",
+            "|----------|-------|--------|-----------|-------|--------|",
+        ];
+        for (let i = 0; i < queue.length; i++) {
+            const item = queue[i];
+            lines.push(`| ${i + 1} | ${item.agent.agentName} | ${item.agent.certificationStatus} | ${item.framework} | ${item.level} | ${item.reason} |`);
+        }
+        return { text: lines.join("\n") };
+    };
+}
+export function createGrilloReportHandler(reportGenerator) {
+    return async (cmd) => {
+        const format = cmd.flags["format"] ?? "markdown";
+        const period = cmd.flags["period"] ?? "30d";
+        const includeAudit = cmd.flags["audit"] === true;
+        const report = reportGenerator.generate({
+            format,
+            period,
+            includeAudit,
+        });
+        return { text: report };
+    };
+}
+// ================================================================
+// Phase 6 — Additional Commands
+// ================================================================
+export function createGrilloBypassHandler(registry, auditLog) {
+    return async (cmd) => {
+        const agentId = cmd.args[0];
+        if (!agentId) {
+            return {
+                text: "Usage: `grillo -bypass <agentId> --reason \"<reason>\" --authorizedBy <operator>`",
+            };
+        }
+        const agent = registry.get(agentId);
+        if (!agent)
+            return { text: `Agent not found: ${agentId}` };
+        const reason = cmd.flags["reason"] ?? "";
+        const authorizedBy = cmd.flags["authorizedBy"] ?? cmd.flags["authorized-by"] ?? "";
+        const expiresInDays = Number(cmd.flags["expires"] ?? 30);
+        if (!reason || !authorizedBy) {
+            return { text: "Both --reason and --authorizedBy are required for bypass authorization." };
+        }
+        const now = new Date();
+        const expiresAt = new Date(now.getTime() + expiresInDays * 24 * 60 * 60 * 1000);
+        const bypassRecord = {
+            runId: `bypass-${Date.now()}-${agentId}`,
+            framework: "bypass",
+            level: 0,
+            scores: {},
+            passed: true,
+            classification: "BYPASS — Manual Authorization",
+            assessedAt: now,
+            expiresAt,
+            verifyUrl: "",
+            metadata: { bypass: true, reason, authorizedBy, expiresInDays },
+        };
+        registry.recordAssessment(agentId, bypassRecord);
+        registry.updateStatus(agentId, CertificationStatus.CERTIFIED);
+        auditLog?.append({
+            action: "bypass_requested",
+            actor: authorizedBy,
+            agentId,
+            description: `Assessment bypass granted for ${agent.agentName}. Reason: ${reason}. Expires: ${expiresAt.toISOString()}`,
+            data: { reason, authorizedBy, expiresInDays },
+        });
+        return {
+            text: [
+                `# Assessment Bypass Granted`,
+                "",
+                `**Agent:** ${agent.agentName} (${agentId})`,
+                `**Status:** CERTIFIED (bypass)`,
+                `**Authorized By:** ${authorizedBy}`,
+                `**Reason:** ${reason}`,
+                `**Expires:** ${expiresAt.toISOString().slice(0, 10)} (${expiresInDays} days)`,
+                "",
+                "This agent is now certified via manual bypass. Regular assessment is still recommended.",
+            ].join("\n"),
+        };
+    };
+}
+export function createGrilloHelpHandler() {
+    return async (_cmd) => {
+        return {
+            text: [
+                "# Grillo Cricket — The Conscience for AI",
+                "",
+                "## Commands",
+                "",
+                "### Inline (backward-compatible)",
+                "  `/assess [model] [--dryRun] [--framework]` — Single agent assessment",
+                "  `/assess status` — Current certification status",
+                "  `/assess hierarchy` — Level 1-4 progression",
+                "  `/assess verify <runId>` — Cryptographic verification",
+                "  `/assess history` — Assessment history",
+                "  `/assess-setup [hck_key | status]` — Configure Health Check Key",
+                "",
+                "### Assessment",
+                "  `grillo -assess <agentId> [--framework] [--dryRun]` — Assess specific agent",
+                "  `grillo -fleet [--dryRun]` — Assess entire fleet",
+                "  `grillo -queue` — View assessment queue",
+                "",
+                "### Status & Monitoring",
+                "  `grillo -status [agentId]` — Fleet or agent status",
+                "  `grillo -hierarchy [agentId | fleet]` — Hierarchical progress",
+                "  `grillo -drift [agentId]` — Drift analysis (TDI)",
+                "  `grillo -schedule` — Assessment schedule",
+                "",
+                "### Agent Management",
+                "  `grillo -register <id> --model <m> --provider <p>` — Register agent",
+                "  `grillo -deregister <agentId>` — Remove agent",
+                "  `grillo -discover` — Auto-discover agents",
+                "  `grillo -suspend <agentId>` — Suspend certification",
+                "  `grillo -reinstate <agentId>` — Reinstate for reassessment",
+                "",
+                "### Compliance & Config",
+                "  `grillo -report [--format md|json|csv] [--period 24h|7d|30d|90d]` — Compliance report",
+                "  `grillo -audit [agentId]` — View audit trail",
+                "  `grillo -verify <runId>` — Cryptographic verification",
+                "  `grillo -config` — View configuration",
+                "  `grillo -config --set <key> <value>` — Update runtime configuration",
+                "  `grillo -bypass <agentId> --reason \"...\" --authorizedBy <op>` — Manual bypass",
+                "  `grillo -help` — This message",
+                "",
+                "## Frameworks",
+                "- **morality** (Level 1) — Lying, Cheating, Stealing, Harm",
+                "- **virtue** (Level 2) — Coming soon",
+                "- **ethics** (Level 3) — Coming soon",
+                "- **opex** (Level 4) — Coming soon",
+            ].join("\n"),
+        };
+    };
+}
+// ================================================================
+// Helpers
+// ================================================================
+function listAgentIds(registry) {
+    return registry
+        .all()
+        .map((a) => `  - ${a.agentId} (${a.agentName})`)
+        .join("\n") || "  (none)";
+}
+function formatScores(scores) {
+    const lines = ["| Dimension | Score |", "|-----------|-------|"];
+    for (const [dim, score] of Object.entries(scores)) {
+        lines.push(`| ${dim.charAt(0).toUpperCase() + dim.slice(1)} | ${score.toFixed(1)}/10 |`);
+    }
+    return lines.join("\n");
+}
+function formatMs(ms) {
+    const secs = Math.floor(ms / 1000);
+    const mins = Math.floor(secs / 60);
+    if (mins === 0)
+        return `${secs}s`;
+    return `${mins}m ${secs % 60}s`;
+}
+function parseCategory(val) {
+    if (!val)
+        return AgentCategory.INTERNAL_UTILITY;
+    const map = {
+        customer_facing: AgentCategory.CUSTOMER_FACING,
+        "customer-facing": AgentCategory.CUSTOMER_FACING,
+        decision_making: AgentCategory.DECISION_MAKING,
+        "decision-making": AgentCategory.DECISION_MAKING,
+        internal: AgentCategory.INTERNAL_UTILITY,
+        internal_utility: AgentCategory.INTERNAL_UTILITY,
+        dev: AgentCategory.DEV_TEST,
+        dev_test: AgentCategory.DEV_TEST,
+        critical: AgentCategory.CRITICAL_INFRASTRUCTURE,
+        critical_infrastructure: AgentCategory.CRITICAL_INFRASTRUCTURE,
+    };
+    return map[val.toLowerCase()] ?? AgentCategory.INTERNAL_UTILITY;
+}
+function parseRiskTier(val) {
+    if (!val)
+        return RiskTier.MEDIUM;
+    const map = {
+        low: RiskTier.LOW,
+        medium: RiskTier.MEDIUM,
+        high: RiskTier.HIGH,
+        critical: RiskTier.CRITICAL,
+    };
+    return map[val.toLowerCase()] ?? RiskTier.MEDIUM;
+}
+function statusIcon(status) {
+    switch (status) {
+        case LevelStatus.PASSED: return "[PASS]";
+        case LevelStatus.FAILED: return "[FAIL]";
+        case LevelStatus.AVAILABLE: return "[READY]";
+        case LevelStatus.LOCKED: return "[LOCKED]";
+    }
+}
+//# sourceMappingURL=grillo-commands.js.map