@hybridaione/hybridclaw 0.2.3 → 0.2.7

package/src/health.ts

@@ -1,21 +1,25 @@
 import fs from 'fs';
 import http, { type IncomingMessage, type ServerResponse } from 'http';
 import path from 'path';
-
-import { GATEWAY_API_TOKEN, HEALTH_HOST, HEALTH_PORT, WEB_API_TOKEN } from './config.js';
+import { runDiscordToolAction } from './channels/discord/runtime.js';
+import type { DiscordToolActionRequest } from './channels/discord/tool-actions.js';
+import {
+  GATEWAY_API_TOKEN,
+  HEALTH_HOST,
+  HEALTH_PORT,
+  WEB_API_TOKEN,
+} from './config.js';
 import {
+  type GatewayChatRequest,
+  type GatewayCommandRequest,
   getGatewayHistory,
   getGatewayStatus,
   handleGatewayCommand,
   handleGatewayMessage,
-  type GatewayCommandRequest,
-  type GatewayChatRequest,
 } from './gateway-service.js';
-import { type GatewayChatRequestBody } from './gateway-types.js';
-import { type DiscordToolActionRequest } from './channels/discord/tool-actions.js';
-import { runDiscordToolAction } from './channels/discord/runtime.js';
-import { type ToolProgressEvent } from './types.js';
+import type { GatewayChatRequestBody } from './gateway-types.js';
 import { logger } from './logger.js';
+import type { ToolProgressEvent } from './types.js';
 
 const SITE_DIR = path.resolve(process.cwd(), 'docs');
 const MAX_REQUEST_BYTES = 1_000_000; // 1MB
@@ -40,7 +44,8 @@ function isLoopbackAddress(address: string | undefined): boolean {
 
 function hasApiAuth(req: IncomingMessage): boolean {
   const authHeader = req.headers.authorization || '';
-  const gatewayTokenMatch = Boolean(GATEWAY_API_TOKEN) && authHeader === `Bearer ${GATEWAY_API_TOKEN}`;
+  const gatewayTokenMatch =
+    Boolean(GATEWAY_API_TOKEN) && authHeader === `Bearer ${GATEWAY_API_TOKEN}`;
 
   if (!WEB_API_TOKEN) {
     return gatewayTokenMatch || isLoopbackAddress(req.socket.remoteAddress);
@@ -49,8 +54,14 @@ function hasApiAuth(req: IncomingMessage): boolean {
   return gatewayTokenMatch;
 }
 
-function sendJson(res: ServerResponse, statusCode: number, payload: unknown): void {
-  res.writeHead(statusCode, { 'Content-Type': 'application/json; charset=utf-8' });
+function sendJson(
+  res: ServerResponse,
+  statusCode: number,
+  payload: unknown,
+): void {
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json; charset=utf-8',
+  });
   res.end(JSON.stringify(payload, null, 2));
 }
 
@@ -81,12 +92,15 @@ function resolveSiteFile(pathname: string): string | null {
   const normalized = path.normalize(cleanPath).replace(/^(\.\.(\/|\\|$))+/, '');
   const candidate = path.resolve(SITE_DIR, `.${normalized}`);
   if (!candidate.startsWith(SITE_DIR)) return null;
-  if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile()) return null;
+  if (!fs.existsSync(candidate) || !fs.statSync(candidate).isFile())
+    return null;
   return candidate;
 }
 
 function serveStatic(pathname: string, res: ServerResponse): boolean {
-  const filePath = resolveSiteFile(pathname === '/chat' ? '/chat.html' : pathname);
+  const filePath = resolveSiteFile(
+    pathname === '/chat' ? '/chat.html' : pathname,
+  );
   if (!filePath) return false;
   const ext = path.extname(filePath).toLowerCase();
   const mimeType = MIME_TYPES[ext] || 'application/octet-stream';
@@ -95,8 +109,11 @@ function serveStatic(pathname: string, res: ServerResponse): boolean {
   return true;
 }
 
-async function handleApiChat(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  const body = await readJsonBody(req) as Partial<ApiChatRequestBody>;
+async function handleApiChat(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<void> {
+  const body = (await readJsonBody(req)) as Partial<ApiChatRequestBody>;
   const wantsStream = body.stream === true;
 
   const content = body.content?.trim();
@@ -177,7 +194,10 @@ async function handleApiChatStream(
         error: errorMessage,
       },
     });
-    logger.error({ error, reqUrl: '/api/chat' }, 'Gateway streaming chat failed');
+    logger.error(
+      { error, reqUrl: '/api/chat' },
+      'Gateway streaming chat failed',
+    );
   } finally {
     if (!res.writableEnded) {
       res.end();
@@ -191,11 +211,18 @@ async function handleApiChatStream(
   });
 }
 
-async function handleApiCommand(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  const body = await readJsonBody(req) as Partial<GatewayCommandRequest>;
-  const args = Array.isArray(body.args) ? body.args.map((value) => String(value)) : [];
+async function handleApiCommand(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<void> {
+  const body = (await readJsonBody(req)) as Partial<GatewayCommandRequest>;
+  const args = Array.isArray(body.args)
+    ? body.args.map((value) => String(value))
+    : [];
   if (args.length === 0) {
-    sendJson(res, 400, { error: 'Missing command. Provide non-empty `args` array.' });
+    sendJson(res, 400, {
+      error: 'Missing command. Provide non-empty `args` array.',
+    });
     return;
   }
 
@@ -209,12 +236,20 @@ async function handleApiCommand(req: IncomingMessage, res: ServerResponse): Prom
   sendJson(res, result.kind === 'error' ? 400 : 200, result);
 }
 
-async function handleApiDiscordAction(req: IncomingMessage, res: ServerResponse): Promise<void> {
-  const body = await readJsonBody(req) as ApiDiscordActionRequestBody;
+async function handleApiDiscordAction(
+  req: IncomingMessage,
+  res: ServerResponse,
+): Promise<void> {
+  const body = (await readJsonBody(req)) as ApiDiscordActionRequestBody;
   const action = typeof body.action === 'string' ? body.action.trim() : '';
-  if (action !== 'read' && action !== 'member-info' && action !== 'channel-info') {
+  if (
+    action !== 'read' &&
+    action !== 'member-info' &&
+    action !== 'channel-info'
+  ) {
     sendJson(res, 400, {
-      error: 'Invalid `action`. Allowed: "read", "member-info", "channel-info".',
+      error:
+        'Invalid `action`. Allowed: "read", "member-info", "channel-info".',
     });
     return;
   }
@@ -268,7 +303,9 @@ export function startHealthServer(): void {
 
     if (pathname.startsWith('/api/')) {
       if (!hasApiAuth(req)) {
-        sendJson(res, 401, { error: 'Unauthorized. Set `Authorization: Bearer <WEB_API_TOKEN>`.' });
+        sendJson(res, 401, {
+          error: 'Unauthorized. Set `Authorization: Bearer <WEB_API_TOKEN>`.',
+        });
         return;
       }
 
@@ -312,6 +349,9 @@ export function startHealthServer(): void {
   });
 
   server.listen(HEALTH_PORT, HEALTH_HOST, () => {
-    logger.info({ host: HEALTH_HOST, port: HEALTH_PORT }, 'Gateway HTTP server started');
+    logger.info(
+      { host: HEALTH_HOST, port: HEALTH_PORT },
+      'Gateway HTTP server started',
+    );
   });
 }

package/src/heartbeat.ts

@@ -2,17 +2,35 @@
  * Heartbeat — periodic poll so the agent can proactively check tasks,
  * maintain memory, and reach out when needed.
  */
-import { HEARTBEAT_CHANNEL, HEARTBEAT_ENABLED, HYBRIDAI_CHATBOT_ID, HYBRIDAI_ENABLE_RAG, HYBRIDAI_MODEL } from './config.js';
+
 import { runAgent } from './agent.js';
-import { getConversationHistory, getOrCreateSession, getTasksForSession, storeMessage } from './db.js';
+import {
+  emitToolExecutionAuditEvents,
+  makeAuditRunId,
+  recordAuditEvent,
+} from './audit-events.js';
+import {
+  HEARTBEAT_CHANNEL,
+  HEARTBEAT_ENABLED,
+  HYBRIDAI_CHATBOT_ID,
+  HYBRIDAI_ENABLE_RAG,
+  HYBRIDAI_MODEL,
+} from './config.js';
+import { buildConversationContext } from './conversation.js';
+import { getTasksForSession } from './db.js';
 import { logger } from './logger.js';
-import { processSideEffects } from './side-effects.js';
+import { memoryService } from './memory-service.js';
+import {
+  isWithinActiveHours,
+  proactiveWindowLabel,
+} from './proactive-policy.js';
 import { maybeCompactSession } from './session-maintenance.js';
 import { appendSessionTranscript } from './session-transcripts.js';
-import { buildConversationContext } from './conversation.js';
-import { isWithinActiveHours, proactiveWindowLabel } from './proactive-policy.js';
-import { emitToolExecutionAuditEvents, makeAuditRunId, recordAuditEvent } from './audit-events.js';
-import { estimateTokenCountFromMessages, estimateTokenCountFromText } from './token-efficiency.js';
+import { processSideEffects } from './side-effects.js';
+import {
+  estimateTokenCountFromMessages,
+  estimateTokenCountFromText,
+} from './token-efficiency.js';
 
 const HEARTBEAT_PROMPT =
   '[Heartbeat poll] Check HEARTBEAT.md for periodic tasks. If nothing needs attention, reply HEARTBEAT_OK.';
@@ -53,7 +71,10 @@ let timer: ReturnType<typeof setInterval> | null = null;
 let running = false;
 
 function isHeartbeatOk(text: string): boolean {
-  const normalized = text.trim().replace(/[^a-z_]/gi, '').toUpperCase();
+  const normalized = text
+    .trim()
+    .replace(/[^a-z_]/gi, '')
+    .toUpperCase();
   return normalized === 'HEARTBEATOK' || normalized.startsWith('HEARTBEATOK');
 }
 
@@ -75,7 +96,10 @@ export function startHeartbeat(
       return;
     }
     if (!isWithinActiveHours()) {
-      logger.debug({ activeHours: proactiveWindowLabel() }, 'Heartbeat skipped — outside active hours window');
+      logger.debug(
+        { activeHours: proactiveWindowLabel() },
+        'Heartbeat skipped — outside active hours window',
+      );
       return;
     }
     running = true;
@@ -87,13 +111,24 @@ export function startHeartbeat(
     let turnIndex = 1;
 
     try {
-      const session = getOrCreateSession(sessionId, null, channelId);
+      const session = memoryService.getOrCreateSession(
+        sessionId,
+        null,
+        channelId,
+      );
       turnIndex = session.message_count + 1;
 
-      const history = getConversationHistory(sessionId, MAX_HEARTBEAT_HISTORY);
+      const history = memoryService.getConversationHistory(
+        sessionId,
+        MAX_HEARTBEAT_HISTORY,
+      );
+      const memoryContext = memoryService.buildPromptMemoryContext({
+        session,
+        query: HEARTBEAT_PROMPT,
+      });
       const { messages } = buildConversationContext({
         agentId,
-        sessionSummary: session.session_summary,
+        sessionSummary: memoryContext.promptSummary,
         history,
       });
       messages.push({ role: 'user', content: HEARTBEAT_PROMPT });
@@ -141,13 +176,24 @@ export function startHeartbeat(
         toolExecutions: output.toolExecutions || [],
       });
       const tokenUsage = output.tokenUsage;
-      const estimatedPromptTokens = tokenUsage?.estimatedPromptTokens || estimateTokenCountFromMessages(messages);
-      const estimatedCompletionTokens = tokenUsage?.estimatedCompletionTokens || estimateTokenCountFromText(output.result || '');
-      const estimatedTotalTokens = tokenUsage?.estimatedTotalTokens || (estimatedPromptTokens + estimatedCompletionTokens);
+      const estimatedPromptTokens =
+        tokenUsage?.estimatedPromptTokens ||
+        estimateTokenCountFromMessages(messages);
+      const estimatedCompletionTokens =
+        tokenUsage?.estimatedCompletionTokens ||
+        estimateTokenCountFromText(output.result || '');
+      const estimatedTotalTokens =
+        tokenUsage?.estimatedTotalTokens ||
+        estimatedPromptTokens + estimatedCompletionTokens;
       const apiUsageAvailable = tokenUsage?.apiUsageAvailable === true;
       const apiPromptTokens = tokenUsage?.apiPromptTokens || 0;
       const apiCompletionTokens = tokenUsage?.apiCompletionTokens || 0;
-      const apiTotalTokens = tokenUsage?.apiTotalTokens || (apiPromptTokens + apiCompletionTokens);
+      const apiTotalTokens =
+        tokenUsage?.apiTotalTokens || apiPromptTokens + apiCompletionTokens;
+      const apiCacheUsageAvailable =
+        tokenUsage?.apiCacheUsageAvailable === true;
+      const apiCacheReadTokens = tokenUsage?.apiCacheReadTokens || 0;
+      const apiCacheWriteTokens = tokenUsage?.apiCacheWriteTokens || 0;
       recordAuditEvent({
         sessionId,
         runId,
@@ -158,9 +204,15 @@ export function startHeartbeat(
           durationMs: Date.now() - startedAt,
           toolCallCount: (output.toolExecutions || []).length,
           modelCalls: tokenUsage ? Math.max(1, tokenUsage.modelCalls) : 0,
-          promptTokens: apiUsageAvailable ? apiPromptTokens : estimatedPromptTokens,
-          completionTokens: apiUsageAvailable ? apiCompletionTokens : estimatedCompletionTokens,
-          totalTokens: apiUsageAvailable ? apiTotalTokens : estimatedTotalTokens,
+          promptTokens: apiUsageAvailable
+            ? apiPromptTokens
+            : estimatedPromptTokens,
+          completionTokens: apiUsageAvailable
+            ? apiCompletionTokens
+            : estimatedCompletionTokens,
+          totalTokens: apiUsageAvailable
+            ? apiTotalTokens
+            : estimatedTotalTokens,
           estimatedPromptTokens,
           estimatedCompletionTokens,
           estimatedTotalTokens,
@@ -168,6 +220,17 @@ export function startHeartbeat(
           apiPromptTokens,
           apiCompletionTokens,
           apiTotalTokens,
+          ...(apiCacheUsageAvailable
+            ? {
+                apiCacheUsageAvailable,
+                apiCacheReadTokens,
+                apiCacheWriteTokens,
+                cacheReadTokens: apiCacheReadTokens,
+                cacheReadInputTokens: apiCacheReadTokens,
+                cacheWriteTokens: apiCacheWriteTokens,
+                cacheWriteInputTokens: apiCacheWriteTokens,
+              }
+            : {}),
         },
       });
       processSideEffects(output, sessionId, heartbeatChannelId);
@@ -241,8 +304,19 @@ export function startHeartbeat(
       }
 
       // Real content — persist and deliver
-      storeMessage(sessionId, 'heartbeat', 'heartbeat', 'user', HEARTBEAT_PROMPT);
-      storeMessage(sessionId, 'assistant', null, 'assistant', result);
+      memoryService.storeTurn({
+        sessionId,
+        user: {
+          userId: 'heartbeat',
+          username: 'heartbeat',
+          content: HEARTBEAT_PROMPT,
+        },
+        assistant: {
+          userId: 'assistant',
+          username: null,
+          content: result,
+        },
+      });
       appendSessionTranscript(agentId, {
         sessionId,
         channelId: heartbeatChannelId,
@@ -267,7 +341,10 @@ export function startHeartbeat(
         model: HYBRIDAI_MODEL,
         channelId: heartbeatChannelId,
       });
-      logger.info({ length: result.length }, 'Heartbeat: agent has something to say');
+      logger.info(
+        { length: result.length },
+        'Heartbeat: agent has something to say',
+      );
       recordAuditEvent({
         sessionId,
         runId,

package/src/hybridai-bots.ts

@@ -1,4 +1,4 @@
-import { HYBRIDAI_BASE_URL, getHybridAIApiKey } from './config.js';
+import { getHybridAIApiKey, HYBRIDAI_BASE_URL } from './config.js';
 import type { HybridAIBot } from './types.js';
 
 interface BotCacheEntry {
@@ -10,18 +10,27 @@ let botCache: BotCacheEntry | null = null;
 
 function normalizeBots(payload: unknown): HybridAIBot[] {
   const data = payload as
-    | { data?: Record<string, unknown>[]; bots?: Record<string, unknown>[]; items?: Record<string, unknown>[] }
+    | {
+        data?: Record<string, unknown>[];
+        bots?: Record<string, unknown>[];
+        items?: Record<string, unknown>[];
+      }
     | Record<string, unknown>[];
-  const raw = Array.isArray(data) ? data : (data.data || data.bots || data.items || []);
+  const raw = Array.isArray(data)
+    ? data
+    : data.data || data.bots || data.items || [];
 
   return raw.map((item) => ({
     id: String(item.id ?? item._id ?? item.chatbot_id ?? item.bot_id ?? ''),
     name: String(item.bot_name ?? item.name ?? 'Unnamed'),
-    description: item.description != null ? String(item.description) : undefined,
+    description:
+      item.description != null ? String(item.description) : undefined,
   }));
 }
 
-export async function fetchHybridAIBots(options?: { cacheTtlMs?: number }): Promise<HybridAIBot[]> {
+export async function fetchHybridAIBots(options?: {
+  cacheTtlMs?: number;
+}): Promise<HybridAIBot[]> {
   const cacheTtlMs = Math.max(0, options?.cacheTtlMs ?? 0);
   const now = Date.now();
 

package/src/hybridai-models.ts

@@ -0,0 +1,158 @@
+interface HybridAIModel {
+  id: string;
+  contextWindowTokens: number | null;
+}
+
+// Source: ../../examples/pi-mono/packages/ai/src/models.generated.ts
+// Keep this list intentionally small and focused on the GPT-5 family we use.
+const STATIC_MODEL_CONTEXT_WINDOWS: Record<string, number> = {
+  // Claude 4.6
+  'claude-opus-4-6': 200_000,
+  'claude-opus-4.6': 200_000,
+  'claude-sonnet-4-6': 200_000,
+  'claude-sonnet-4.6': 200_000,
+
+  // Gemini 3 / 3.1
+  'gemini-3': 1_048_576,
+  'gemini-3-pro': 1_048_576,
+  'gemini-3-flash': 1_048_576,
+  'gemini-3.1': 1_048_576,
+  'gemini-3.1-pro': 1_048_576,
+  'gemini-3.1-pro-high': 1_048_576,
+  'gemini-3.1-pro-low': 1_048_576,
+  'gemini-3-pro-preview': 1_048_576,
+  'gemini-3-flash-preview': 1_048_576,
+  'gemini-3.1-pro-preview': 1_048_576,
+
+  // GPT-5 family
+  'gpt-5': 400_000,
+  'gpt-5-chat-latest': 128_000,
+  'gpt-5-codex': 400_000,
+  'gpt-5-mini': 400_000,
+  'gpt-5-nano': 400_000,
+  'gpt-5-pro': 400_000,
+  'gpt-5.1': 400_000,
+  'gpt-5.1-chat-latest': 128_000,
+  'gpt-5.1-codex': 400_000,
+  'gpt-5.1-codex-max': 400_000,
+  'gpt-5.1-codex-mini': 400_000,
+  'gpt-5.2': 400_000,
+  'gpt-5.2-chat-latest': 128_000,
+  'gpt-5.2-codex': 400_000,
+  'gpt-5.2-pro': 400_000,
+  'gpt-5.3-codex': 400_000,
+  'gpt-5.3-codex-spark': 128_000,
+};
+
+export function resolveModelContextWindowFromList(
+  models: HybridAIModel[],
+  modelName: string,
+): number | null {
+  const normalizeModelIdTail = (modelId: string): string => {
+    const normalized = modelId.trim().toLowerCase();
+    return normalized.includes('/')
+      ? (normalized.split('/').at(-1) ?? normalized)
+      : normalized;
+  };
+  const matchesModelFamily = (
+    candidateId: string,
+    targetId: string,
+  ): boolean => {
+    if (!candidateId || !targetId) return false;
+    if (candidateId === targetId) return true;
+    const boundary = candidateId.at(targetId.length);
+    return (
+      candidateId.startsWith(targetId) &&
+      (boundary === '-' ||
+        boundary === '.' ||
+        boundary === ':' ||
+        boundary === '/')
+    );
+  };
+
+  const target = modelName.trim().toLowerCase();
+  if (!target) return null;
+
+  const direct = models.find(
+    (entry) =>
+      entry.contextWindowTokens != null &&
+      entry.id.trim().toLowerCase() === target,
+  );
+  if (direct?.contextWindowTokens != null) return direct.contextWindowTokens;
+
+  const targetTail = target.includes('/')
+    ? (target.split('/').at(-1) ?? '')
+    : target;
+  if (!targetTail) return null;
+
+  const tailMatch = models.find((entry) => {
+    if (entry.contextWindowTokens == null) return false;
+    const normalizedTail = normalizeModelIdTail(entry.id);
+    return normalizedTail === targetTail;
+  });
+  if (tailMatch?.contextWindowTokens != null)
+    return tailMatch.contextWindowTokens;
+
+  const familyMatch = models
+    .filter((entry) => entry.contextWindowTokens != null)
+    .map((entry) => ({
+      contextWindowTokens: entry.contextWindowTokens as number,
+      tail: normalizeModelIdTail(entry.id),
+    }))
+    .filter((entry) => matchesModelFamily(entry.tail, targetTail))
+    .sort((a, b) => b.tail.length - a.tail.length)
+    .at(0);
+  return familyMatch?.contextWindowTokens ?? null;
+}
+
+export function resolveModelContextWindowFallback(
+  modelName: string,
+): number | null {
+  const matchesModelFamily = (
+    candidateId: string,
+    targetId: string,
+  ): boolean => {
+    if (!candidateId || !targetId) return false;
+    if (candidateId === targetId) return true;
+    const boundary = candidateId.at(targetId.length);
+    return (
+      candidateId.startsWith(targetId) &&
+      (boundary === '-' ||
+        boundary === '.' ||
+        boundary === ':' ||
+        boundary === '/')
+    );
+  };
+
+  const normalized = modelName.trim().toLowerCase();
+  if (!normalized) return null;
+
+  const direct = STATIC_MODEL_CONTEXT_WINDOWS[normalized];
+  if (direct != null) return direct;
+
+  const slashTail = normalized.includes('/')
+    ? (normalized.split('/').at(-1) ?? '')
+    : normalized;
+  if (slashTail && STATIC_MODEL_CONTEXT_WINDOWS[slashTail] != null) {
+    return STATIC_MODEL_CONTEXT_WINDOWS[slashTail];
+  }
+
+  const colonTail = normalized.includes(':')
+    ? (normalized.split(':').at(-1) ?? '')
+    : normalized;
+  if (colonTail && STATIC_MODEL_CONTEXT_WINDOWS[colonTail] != null) {
+    return STATIC_MODEL_CONTEXT_WINDOWS[colonTail];
+  }
+
+  // Family fallback for versioned ids, e.g. "gpt-5.1-2025-11-13".
+  const familyCandidates = [slashTail, colonTail, normalized].filter(Boolean);
+  for (const candidate of familyCandidates) {
+    const bestMatch = Object.keys(STATIC_MODEL_CONTEXT_WINDOWS)
+      .filter((key) => matchesModelFamily(candidate, key))
+      .sort((a, b) => b.length - a.length)
+      .at(0);
+    if (bestMatch) return STATIC_MODEL_CONTEXT_WINDOWS[bestMatch] ?? null;
+  }
+
+  return null;
+}

package/src/instruction-approval-audit.ts

@@ -22,7 +22,10 @@ function ensureAuditReady(): boolean {
     initDatabase({ quiet: true });
     auditReady = true;
   } catch (err) {
-    logger.warn({ err }, 'Failed to initialize DB for instruction approval audit');
+    logger.warn(
+      { err },
+      'Failed to initialize DB for instruction approval audit',
+    );
     auditReady = false;
   }
   return auditReady;

package/src/instruction-integrity.ts

@@ -2,9 +2,18 @@ import { createHash } from 'crypto';
 import fs from 'fs';
 import path from 'path';
 
-export const INSTRUCTION_FILES = ['AGENTS.md', 'SECURITY.md', 'TRUST_MODEL.md'] as const;
+export const INSTRUCTION_FILES = [
+  'AGENTS.md',
+  'SECURITY.md',
+  'TRUST_MODEL.md',
+] as const;
 export const INSTRUCTION_BASELINE_VERSION = 1;
-export const INSTRUCTION_BASELINE_PATH = path.join(process.cwd(), 'data', 'audit', 'instruction-hashes.json');
+export const INSTRUCTION_BASELINE_PATH = path.join(
+  process.cwd(),
+  'data',
+  'audit',
+  'instruction-hashes.json',
+);
 
 export interface InstructionHashBaseline {
   version: number;
@@ -29,7 +38,9 @@ export interface InstructionIntegrityResult {
   files: InstructionFileResult[];
 }
 
-export function summarizeInstructionIntegrity(result: InstructionIntegrityResult): string {
+export function summarizeInstructionIntegrity(
+  result: InstructionIntegrityResult,
+): string {
   if (result.baselineError) return `baseline.invalid (${result.baselineError})`;
   if (!result.baseline) return 'baseline.missing';
 
@@ -62,19 +73,24 @@ export function loadInstructionBaseline(): InstructionHashBaseline | null {
 
   const raw = fs.readFileSync(INSTRUCTION_BASELINE_PATH, 'utf-8');
   const parsed = JSON.parse(raw) as unknown;
-  if (!isRecord(parsed)) throw new Error('Instruction baseline is not a JSON object.');
+  if (!isRecord(parsed))
+    throw new Error('Instruction baseline is not a JSON object.');
 
   const version = parsed.version;
   const approvedAt = parsed.approvedAt;
   const files = parsed.files;
-  if (typeof version !== 'number') throw new Error('Instruction baseline is missing numeric `version`.');
+  if (typeof version !== 'number')
+    throw new Error('Instruction baseline is missing numeric `version`.');
   if (version !== INSTRUCTION_BASELINE_VERSION) {
-    throw new Error(`Instruction baseline version ${String(version)} is unsupported.`);
+    throw new Error(
+      `Instruction baseline version ${String(version)} is unsupported.`,
+    );
   }
   if (typeof approvedAt !== 'string' || !approvedAt.trim()) {
     throw new Error('Instruction baseline is missing `approvedAt`.');
   }
-  if (!isRecord(files)) throw new Error('Instruction baseline is missing `files` object.');
+  if (!isRecord(files))
+    throw new Error('Instruction baseline is missing `files` object.');
 
   const normalizedFiles: Record<string, string> = {};
   for (const relPath of INSTRUCTION_FILES) {
@@ -95,7 +111,9 @@ export function approveInstructionBaseline(): InstructionHashBaseline {
   const hashes = computeCurrentHashes();
   const missing = INSTRUCTION_FILES.filter((relPath) => !hashes[relPath]);
   if (missing.length > 0) {
-    throw new Error(`Approval failed: missing instruction files (${missing.join(', ')}).`);
+    throw new Error(
+      `Approval failed: missing instruction files (${missing.join(', ')}).`,
+    );
   }
 
   const baseline: InstructionHashBaseline = {
@@ -165,7 +183,10 @@ export function verifyInstructionBaseline(): InstructionIntegrityResult {
     };
   });
 
-  const ok = baselineError === null && baseline !== null && files.every((file) => file.status === 'ok');
+  const ok =
+    baselineError === null &&
+    baseline !== null &&
+    files.every((file) => file.status === 'ok');
   return {
     ok,
     baselinePath: INSTRUCTION_BASELINE_PATH,