@complior/engine 0.9.0

package/src/http/routes/chat.route.ts

@@ -0,0 +1,228 @@
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import { z } from 'zod';
+import { streamText, stepCountIs, type CoreMessage } from 'ai';
+import type { ChatService } from '../../services/chat-service.js';
+import { createLogger } from '../../infra/logger.js';
+import type { LlmPort } from '../../ports/llm.port.js';
+import type { ToolExecutorDeps } from '../../llm/tool-executors.js';
+import {
+  sseThinking, sseText, sseToolCall, sseToolResult,
+  sseUsage, sseDone, sseError,
+} from '../../llm/sse-protocol.js';
+import { createCodingTools } from '../../llm/tool-definitions.js';
+import type { AgentMode } from '../../llm/tools/types.js';
+import { getAgentConfig, getAllModes } from '../../llm/agents/modes.js';
+import { createCostTracker, type CostTracker } from '../../llm/routing/cost-tracker.js';
+import { createRateLimiter } from '../../infra/rate-limiter.js';
+import { complior } from '@complior/sdk';
+import { parseBody } from '../utils/validation.js';
+
+const ChatRequestSchema = z.object({
+  message: z.string().min(1),
+  model: z.string().optional(),
+  provider: z.enum(['anthropic', 'openai', 'openrouter']).optional(),
+  apiKey: z.string().optional(),
+  mode: z.enum(['build', 'comply', 'audit', 'learn']).optional(),
+});
+
+export interface ChatRouteDeps {
+  readonly chatService: ChatService;
+  readonly llm: LlmPort;
+  readonly toolExecutorDeps: ToolExecutorDeps;
+  readonly getMode: () => AgentMode;
+  readonly setMode: (mode: AgentMode) => void;
+  readonly maxRequestsPerHour?: number;
+}
+
+const AGENT_MODE_SET = new Set<string>(['build', 'comply', 'audit', 'learn']);
+const isAgentMode = (s: string): s is AgentMode => AGENT_MODE_SET.has(s);
+
+const isRecord = (v: unknown): v is Record<string, unknown> =>
+  typeof v === 'object' && v !== null;
+
+/** Safe property access helpers for stream parts */
+const prop = (obj: unknown, key: string): unknown =>
+  isRecord(obj) && key in obj ? obj[key] : undefined;
+
+const strProp = (obj: unknown, key: string, fallback = ''): string => {
+  const v = prop(obj, key);
+  return typeof v === 'string' ? v : fallback;
+};
+
+const numProp = (obj: unknown, key: string, fallback = 0): number => {
+  const v = prop(obj, key);
+  return typeof v === 'number' ? v : fallback;
+};
+
+/** Parse /command from message. Returns { command, arg } or null. */
+const parseCommand = (msg: string): { command: string; arg: string } | null => {
+  const match = msg.trim().match(/^\/(\w+)\s*(.*)/);
+  return match ? { command: match[1], arg: match[2].trim() } : null;
+};
+
+const chatLog = createLogger('chat-route');
+
+export const createChatRoute = (deps: ChatRouteDeps) => {
+  const { chatService, llm, toolExecutorDeps, getMode, setMode } = deps;
+  const app = new Hono();
+
+  // Session state
+  let modelOverride: string | undefined;
+  const costTracker: CostTracker = createCostTracker();
+
+  // Rate limiting (sliding window)
+  const DEFAULT_MAX_REQUESTS_PER_HOUR = 50;
+  const rateLimiter = createRateLimiter(deps.maxRequestsPerHour ?? DEFAULT_MAX_REQUESTS_PER_HOUR);
+
+  // GET /mode — current mode info
+  app.get('/mode', (c) => c.json({ mode: getMode(), config: getAgentConfig(getMode()) }));
+
+  // POST /mode — switch mode
+  app.post('/mode', async (c) => {
+    const body: Record<string, unknown> = await c.req.json().catch(() => ({}));
+    const mode = typeof body['mode'] === 'string' ? body['mode'] : undefined;
+    if (!mode || !isAgentMode(mode)) {
+      return c.json({ error: 'INVALID_MODE', valid: getAllModes() }, 400);
+    }
+    setMode(mode);
+    return c.json({ mode: getMode(), config: getAgentConfig(getMode()) });
+  });
+
+  // GET /cost — session cost breakdown
+  app.get('/cost', (c) => c.json(costTracker.getBreakdown()));
+
+  app.post('/chat', async (c) => {
+    const parsed = await parseBody(c, ChatRequestSchema);
+
+    // Handle slash commands
+    const cmd = parseCommand(parsed.message);
+    if (cmd) {
+      if (cmd.command === 'mode' && cmd.arg) {
+        if (isAgentMode(cmd.arg)) {
+          setMode(cmd.arg);
+          const config = getAgentConfig(getMode());
+          return c.json({ type: 'command', command: 'mode', mode: getMode(), label: config.label, writeEnabled: config.writeEnabled });
+        }
+        return c.json({ type: 'command', command: 'mode', error: `Invalid mode. Valid: ${getAllModes().join(', ')}` });
+      }
+      if (cmd.command === 'cost') {
+        return c.json({ type: 'command', command: 'cost', ...costTracker.getBreakdown() });
+      }
+      if (cmd.command === 'model' && cmd.arg) {
+        modelOverride = cmd.arg === 'auto' ? undefined : cmd.arg;
+        return c.json({ type: 'command', command: 'model', model: modelOverride ?? 'auto-routing', message: modelOverride ? `Model locked to ${modelOverride}` : 'Auto-routing enabled' });
+      }
+    }
+
+    // Rate limiting — sliding window
+    if (!rateLimiter.check()) {
+      return c.json({ error: 'RATE_LIMIT', message: 'Chat rate limit exceeded' }, 429);
+    }
+
+    // Apply mode from request or session
+    if (parsed.mode) setMode(parsed.mode);
+
+    const { provider, modelId } = parsed.provider && parsed.model
+      ? { provider: parsed.provider, modelId: parsed.model }
+      : llm.routeModel(modelOverride ?? 'chat', parsed.provider);
+    const model = await llm.getModel(provider, modelId, parsed.apiKey);
+
+    // Use mode-specific system prompt
+    const modeConfig = getAgentConfig(getMode());
+    const systemPrompt = `${modeConfig.systemPrompt}\n\n${await chatService.buildSystemPrompt()}`;
+    const tools = createCodingTools(chatService.getProjectPath(), toolExecutorDeps);
+
+    // Append user message to conversation history
+    const userMessage: CoreMessage = { role: 'user', content: parsed.message };
+    chatService.appendConversationHistory(userMessage);
+
+    return streamSSE(c, async (stream) => {
+      try {
+        const result = complior(streamText)({
+          model: model,
+          system: systemPrompt,
+          messages: chatService.getConversationHistory(),
+          tools,
+          stopWhen: stepCountIs(10),
+        });
+
+        let assistantText = '';
+
+        for await (const part of result.fullStream) {
+          switch (part.type) {
+            case 'text-delta': {
+              const text = strProp(part, 'text') || strProp(part, 'textDelta');
+              assistantText += text;
+              const payload = sseText(text);
+              await stream.writeSSE({ event: payload.event, data: payload.data });
+              break;
+            }
+            case 'reasoning-delta': {
+              const text = strProp(part, 'text') || strProp(part, 'textDelta');
+              const payload = sseThinking(text);
+              await stream.writeSSE({ event: payload.event, data: payload.data });
+              break;
+            }
+            case 'tool-call': {
+              const id = strProp(part, 'toolCallId') || strProp(part, 'toolUseId');
+              const toolName = strProp(part, 'toolName');
+              const rawArgs = prop(part, 'args') ?? prop(part, 'input');
+              const toolArgs = isRecord(rawArgs) ? rawArgs : {};
+              const payload = sseToolCall(id, toolName, toolArgs);
+              await stream.writeSSE({ event: payload.event, data: payload.data });
+              break;
+            }
+            case 'tool-result': {
+              const id = strProp(part, 'toolCallId') || strProp(part, 'toolUseId');
+              const toolName = strProp(part, 'toolName');
+              const resultVal = prop(part, 'result') ?? prop(part, 'output') ?? '';
+              const resultStr = typeof resultVal === 'string' ? resultVal : JSON.stringify(resultVal);
+              const isError = resultStr.includes('"error":true') || resultStr.includes('"error": true');
+              const payload = sseToolResult(id, toolName, resultStr, isError);
+              await stream.writeSSE({ event: payload.event, data: payload.data });
+              break;
+            }
+            case 'finish': {
+              const totalUsage = prop(part, 'totalUsage');
+              if (totalUsage && typeof totalUsage === 'object') {
+                const prompt = numProp(totalUsage, 'promptTokens') || numProp(totalUsage, 'inputTokens');
+                const completion = numProp(totalUsage, 'completionTokens') || numProp(totalUsage, 'outputTokens');
+                costTracker.record('qa', modelId, prompt, completion);
+                const payload = sseUsage(prompt, completion);
+                await stream.writeSSE({ event: payload.event, data: payload.data });
+              }
+              break;
+            }
+            case 'error': {
+              const payload = sseError(String(prop(part, 'error')));
+              await stream.writeSSE({ event: payload.event, data: payload.data });
+              break;
+            }
+            default:
+              break;
+          }
+        }
+
+        // Append assistant response to history
+        if (assistantText) {
+          chatService.appendConversationHistory({ role: 'assistant', content: assistantText });
+        }
+
+        // Persist chat history to disk
+        chatService.saveHistory().catch((e) => chatLog.warn('History save failed:', e));
+
+        const done = sseDone();
+        await stream.writeSSE({ event: done.event, data: done.data });
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        const payload = sseError(message);
+        await stream.writeSSE({ event: payload.event, data: payload.data });
+        const done = sseDone();
+        await stream.writeSSE({ event: done.event, data: done.data });
+      }
+    });
+  });
+
+  return app;
+};

package/src/http/routes/cost.route.ts

@@ -0,0 +1,33 @@
+/**
+ * US-S05-27: Cost Estimation HTTP Route
+ *
+ * GET /cost-estimate?hourlyRate=150&agent=my-bot
+ */
+
+import { Hono } from 'hono';
+import type { CostService } from '../../services/cost-service.js';
+import { DEFAULT_HOURLY_RATE } from '../../domain/shared/compliance-constants.js';
+
+export interface CostRouteDeps {
+  readonly costService: CostService;
+}
+
+export const createCostRoute = (deps: CostRouteDeps) => {
+  const app = new Hono();
+
+  app.get('/cost-estimate', async (c) => {
+    const hourlyRate = Number(c.req.query('hourlyRate')) || DEFAULT_HOURLY_RATE;
+    const agentName = c.req.query('agent') || undefined;
+
+    try {
+      const result = await deps.costService.estimate(hourlyRate, agentName);
+      return c.json(result);
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : 'Cost estimation failed';
+      return c.json({ error: message }, 500);
+    }
+  });
+
+  return app;
+};

package/src/http/routes/debt.route.ts

@@ -0,0 +1,29 @@
+/**
+ * US-S05-22: Compliance Debt Score HTTP Route
+ *
+ * GET /debt
+ */
+
+import { Hono } from 'hono';
+import type { DebtService } from '../../services/debt-service.js';
+
+export interface DebtRouteDeps {
+  readonly debtService: DebtService;
+}
+
+export const createDebtRoute = (deps: DebtRouteDeps) => {
+  const app = new Hono();
+
+  app.get('/debt', async (c) => {
+    try {
+      const trend = c.req.query('trend') === 'true';
+      const result = await deps.debtService.getDebt(trend);
+      return c.json(result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : 'Debt calculation failed';
+      return c.json({ error: message }, 500);
+    }
+  });
+
+  return app;
+};

package/src/http/routes/disclaimer.route.ts

@@ -0,0 +1,64 @@
+import { Hono } from 'hono';
+import {
+  getDisclaimer,
+  getReportFooter,
+  containsBannedPhrase,
+  BANNED_PHRASES,
+  type DisclaimerContext,
+} from '../../domain/disclaimer.js';
+
+const VALID_CONTEXTS = new Set<string>([
+  'system_prompt', 'report_footer', 'compliance_md', 'commit_message', 'chat_response',
+]);
+
+const isDisclaimerContext = (s: string): s is DisclaimerContext => VALID_CONTEXTS.has(s);
+
+export interface DisclaimerRouteDeps {
+  readonly getVersion: () => string;
+}
+
+export const createDisclaimerRoute = (deps: DisclaimerRouteDeps) => {
+  const app = new Hono();
+
+  // GET /disclaimer — list all contexts
+  app.get('/disclaimer', (c) => {
+    return c.json({
+      contexts: [...VALID_CONTEXTS],
+      bannedPhrases: BANNED_PHRASES,
+    });
+  });
+
+  // GET /disclaimer/:context — get disclaimer text for a specific context
+  app.get('/disclaimer/:context', (c) => {
+    const ctx = c.req.param('context');
+    if (!isDisclaimerContext(ctx)) {
+      return c.json(
+        { error: 'INVALID_CONTEXT', message: `Valid contexts: ${[...VALID_CONTEXTS].join(', ')}` },
+        400,
+      );
+    }
+
+    if (ctx === 'report_footer') {
+      return c.json({ context: ctx, text: getReportFooter(deps.getVersion()) });
+    }
+
+    return c.json({ context: ctx, text: getDisclaimer(ctx) });
+  });
+
+  // POST /disclaimer/check — check text for banned phrases
+  app.post('/disclaimer/check', async (c) => {
+    const body: Record<string, unknown> = await c.req.json().catch(() => ({}));
+    const text = typeof body['text'] === 'string' ? body['text'] : '';
+
+    if (!text) {
+      return c.json({ error: 'MISSING_TEXT', message: 'Provide "text" field to check' }, 400);
+    }
+
+    return c.json({
+      hasBannedPhrase: containsBannedPhrase(text),
+      bannedPhrases: BANNED_PHRASES,
+    });
+  });
+
+  return app;
+};

package/src/http/routes/eval.route.ts

@@ -0,0 +1,161 @@
+/**
+ * Eval Route — HTTP endpoints for `complior eval`.
+ *
+ * POST /eval/run              — Run eval against target (blocking JSON)
+ * POST /eval/run/stream       — Run eval with SSE progress streaming
+ * GET  /eval/last             — Get last eval result
+ * GET  /eval/list             — List eval results
+ * GET  /eval/remediation      — Get remediation actions for test IDs (US-REM-07)
+ * POST /eval/remediation-report — Full remediation report (US-REM-08)
+ * GET  /eval/findings         — Get eval failures as scanner findings (US-REM-09)
+ */
+
+import { Hono } from 'hono';
+import { streamSSE } from 'hono/streaming';
+import type { EvalService } from '../../services/eval-service.js';
+import { EvalOptionsSchema, resolveIncludes } from '../../domain/eval/types.js';
+import type { EvalProgress } from '../../domain/eval/types.js';
+import { sseEvalStart, sseEvalHealth, sseEvalTest, sseEvalDone, sseError } from '../../llm/sse-protocol.js';
+import { parseBody, requireQuery } from '../utils/validation.js';
+
+export interface EvalRouteDeps {
+  readonly evalService: EvalService;
+}
+
+export const createEvalRoute = (deps: EvalRouteDeps) => {
+  const app = new Hono();
+
+  // POST /eval/run — run eval (blocking JSON response)
+  app.post('/eval/run', async (c) => {
+    const options = await parseBody(c, EvalOptionsSchema);
+    const result = await deps.evalService.runEval(options);
+    return c.json(result);
+  });
+
+  // POST /eval/run/stream — run eval with SSE progress streaming
+  app.post('/eval/run/stream', async (c) => {
+    const options = await parseBody(c, EvalOptionsSchema);
+    const includes = resolveIncludes(options);
+    const modeLabel = includes.deterministic && includes.llm && includes.security ? 'full'
+      : includes.deterministic && includes.llm ? 'deterministic + LLM-judged'
+      : includes.llm ? 'LLM-judged tests'
+      : includes.security ? 'security probes'
+      : 'deterministic tests';
+
+    return streamSSE(c, async (stream) => {
+      try {
+        // Emit start event (pass model as judgeModel when LLM-judge is enabled)
+        const judgeModel = (includes.llm || includes.security) ? options.model : undefined;
+        const startPayload = sseEvalStart(options.target, options.model, modeLabel, judgeModel);
+        await stream.writeSSE({ event: startPayload.event, data: startPayload.data });
+
+        let healthEmitted = false;
+
+        const onProgress = async (progress: EvalProgress): Promise<void> => {
+          // Emit health check result
+          if (progress.phase === 'health' && progress.completed === 1 && !healthEmitted) {
+            healthEmitted = true;
+            const healthPayload = sseEvalHealth(true);
+            await stream.writeSSE({ event: healthPayload.event, data: healthPayload.data });
+          }
+
+          // Emit per-test result
+          if (progress.lastResult && progress.completed > 0) {
+            const r = progress.lastResult;
+            const testPayload = sseEvalTest({
+              testId: r.testId,
+              name: r.name,
+              category: r.category,
+              method: r.method,
+              verdict: r.verdict,
+              score: r.score,
+              latencyMs: r.latencyMs,
+              phase: progress.phase,
+              completed: progress.completed,
+              total: progress.total,
+              ...(r.owaspCategory ? { owaspCategory: r.owaspCategory } : {}),
+              ...(r.severity ? { severity: r.severity } : {}),
+              ...(r.probe ? { probe: r.probe } : {}),
+              ...(r.response ? { response: r.response } : {}),
+              ...(r.reasoning ? { reasoning: r.reasoning } : {}),
+            });
+            await stream.writeSSE({ event: testPayload.event, data: testPayload.data });
+          }
+        };
+
+        const result = await deps.evalService.runEval(options, onProgress);
+
+        // Emit final result
+        const donePayload = sseEvalDone(result);
+        await stream.writeSSE({ event: donePayload.event, data: donePayload.data });
+      } catch (err) {
+        const errPayload = sseError(err instanceof Error ? err.message : String(err));
+        await stream.writeSSE({ event: errPayload.event, data: errPayload.data });
+      }
+    });
+  });
+
+  // GET /eval/last — get last eval result
+  app.get('/eval/last', async (c) => {
+    const result = await deps.evalService.getLastResult();
+    if (!result) {
+      return c.json({ error: 'NOT_FOUND', message: 'No eval results found' }, 404);
+    }
+    return c.json(result);
+  });
+
+  // GET /eval/list — list eval result files
+  app.get('/eval/list', async (c) => {
+    const results = await deps.evalService.listResults();
+    const judgeConfigured = deps.evalService.isJudgeConfigured();
+    return c.json({ results, judgeConfigured });
+  });
+
+  // GET /eval/remediation?testIds=CT-1-003,CT-1-005 — remediation for specific tests (US-REM-07)
+  app.get('/eval/remediation', async (c) => {
+    const testIdsParam = requireQuery(c, 'testIds');
+
+    const result = await deps.evalService.getLastResult();
+    if (!result) {
+      return c.json({ error: 'NOT_FOUND', message: 'No eval results found. Run complior eval first.' }, 404);
+    }
+
+    const testIds = testIdsParam.split(',').map((s) => s.trim()).filter(Boolean);
+    const remediation = await deps.evalService.getRemediationForTests(testIds, result.results);
+    return c.json(remediation);
+  });
+
+  // POST /eval/remediation-report — full remediation report (US-REM-08)
+  app.post('/eval/remediation-report', async (c) => {
+    const result = await deps.evalService.getLastResult();
+    if (!result) {
+      return c.json({ error: 'NOT_FOUND', message: 'No eval results found. Run complior eval first.' }, 404);
+    }
+
+    const report = await deps.evalService.generateRemediationReport(result);
+
+    // R4: Render markdown via service (route should not import domain)
+    const markdown_report = await deps.evalService.getRemediationReportMarkdown();
+
+    return c.json({ ...report, markdown_report });
+  });
+
+  // POST /eval/apply-fixes — apply Type B eval fixes, return Type A as manual guidance
+  app.post('/eval/apply-fixes', async (c) => {
+    const { applied, manual } = await deps.evalService.applyEvalFixes();
+    return c.json({ applied, manual, appliedCount: applied.length, manualCount: manual.length });
+  });
+
+  // GET /eval/findings — eval failures as scanner findings (US-REM-09)
+  app.get('/eval/findings', async (c) => {
+    const result = await deps.evalService.getLastResult();
+    if (!result) {
+      return c.json({ error: 'NOT_FOUND', message: 'No eval results found. Run complior eval first.' }, 404);
+    }
+
+    const findings = await deps.evalService.getEvalFindings(result);
+    return c.json({ findings });
+  });
+
+  return app;
+};

package/src/http/routes/events.route.test.ts

@@ -0,0 +1,108 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createEventsRoute } from './events.route.js';
+import type { EventBusPort, EventMap, EventHandler } from '../../ports/events.port.js';
+
+const createMockEventBus = (): EventBusPort & { _handlers: Map<string, Set<EventHandler<never>>> } => {
+  const handlers = new Map<string, Set<EventHandler<never>>>();
+  return {
+    _handlers: handlers,
+    on: <K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>) => {
+      if (!handlers.has(event)) handlers.set(event, new Set());
+      handlers.get(event)!.add(handler as EventHandler<never>);
+    },
+    off: <K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>) => {
+      handlers.get(event)?.delete(handler as EventHandler<never>);
+    },
+    emit: <K extends keyof EventMap>(event: K, payload: EventMap[K]) => {
+      const set = handlers.get(event);
+      if (set) for (const h of set) (h as EventHandler<EventMap[K]>)(payload);
+    },
+  };
+};
+
+describe('events route', () => {
+  it('responds with text/event-stream content type', async () => {
+    const events = createMockEventBus();
+    const app = createEventsRoute({ events });
+
+    const res = await app.request('/events');
+    expect(res.status).toBe(200);
+    expect(res.headers.get('content-type')).toContain('text/event-stream');
+  });
+
+  it('registers handlers for agent events on connect', async () => {
+    const events = createMockEventBus();
+    const app = createEventsRoute({ events });
+
+    // Start SSE connection (don't await body — it's streaming)
+    const res = await app.request('/events');
+    expect(res.status).toBe(200);
+
+    // Event bus should have handlers registered
+    expect(events._handlers.has('agent.scan.completed')).toBe(true);
+    expect(events._handlers.has('agent.score.updated')).toBe(true);
+    expect(events._handlers.has('scan.completed')).toBe(true);
+  });
+});
+
+describe('agent events in EventMap', () => {
+  it('agent.scan.completed event can be emitted and received', () => {
+    const events = createMockEventBus();
+    const received: unknown[] = [];
+
+    events.on('agent.scan.completed', (payload) => {
+      received.push(payload);
+    });
+
+    const mockResult = { score: { score: 82 }, findings: [] } as never;
+    events.emit('agent.scan.completed', { agentName: 'test-agent', result: mockResult });
+
+    expect(received).toHaveLength(1);
+    expect(received[0]).toMatchObject({ agentName: 'test-agent' });
+  });
+
+  it('agent.score.updated event can be emitted and received', () => {
+    const events = createMockEventBus();
+    const received: unknown[] = [];
+
+    events.on('agent.score.updated', (payload) => {
+      received.push(payload);
+    });
+
+    events.emit('agent.score.updated', { agentName: 'chat-bot', before: 60, after: 75 });
+
+    expect(received).toHaveLength(1);
+    expect(received[0]).toMatchObject({ agentName: 'chat-bot', before: 60, after: 75 });
+  });
+});
+
+describe('agent strip data extraction', () => {
+  it('extracts name, autonomy_level, and score from passport JSON', () => {
+    const passport = {
+      name: 'core-engine',
+      autonomy_level: 3,
+      compliance: { complior_score: 82 },
+    };
+
+    const name = passport.name;
+    const autonomy = passport.autonomy_level;
+    const score = passport.compliance.complior_score;
+
+    expect(name).toBe('core-engine');
+    expect(autonomy).toBe(3);
+    expect(score).toBe(82);
+  });
+
+  it('handles missing fields gracefully', () => {
+    const passport: Record<string, unknown> = { name: 'minimal' };
+
+    const name = (passport['name'] as string) ?? 'unknown';
+    const autonomy = (passport['autonomy_level'] as number) ?? 0;
+    const compliance = passport['compliance'] as Record<string, unknown> | undefined;
+    const score = (compliance?.['complior_score'] as number) ?? 0;
+
+    expect(name).toBe('minimal');
+    expect(autonomy).toBe(0);
+    expect(score).toBe(0);
+  });
+});