@phuetz/code-buddy 1.0.0 → 1.2.0

package/dist/agent/hermes-runtime-lifecycle.js

@@ -0,0 +1,468 @@
+/**
+ * Hibernate/wake lifecycle semantics for Hermes runtime backends.
+ *
+ * Each backend gets a strategy that maps to concrete CLI invocations:
+ *   - local/wsl/os-sandbox/singularity: lifecycle unsupported (always running or job-based)
+ *   - docker: pause / unpause / inspect
+ *   - ssh: connection close / reconnect
+ *   - modal: app stop / run
+ *   - daytona: workspace stop / start
+ *   - vercel-sandbox: unsupported (no lifecycle API)
+ */
+import os from 'os';
+import { spawnSync } from 'child_process';
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+const UNSUPPORTED_BACKEND_IDS = new Set([
+    'local',
+    'wsl',
+    'os-sandbox',
+    'singularity',
+    'vercel-sandbox',
+]);
+const DEFAULT_TIMEOUT_MS = 30_000;
+const BACKEND_LABELS = {
+    'local': 'Local process',
+    'docker': 'Docker sandbox',
+    'wsl': 'WSL',
+    'os-sandbox': 'Native OS sandbox',
+    'ssh': 'SSH remote shell',
+    'singularity': 'Singularity/Apptainer',
+    'modal': 'Modal',
+    'daytona': 'Daytona',
+    'vercel-sandbox': 'Vercel Sandbox',
+};
+const ALL_BACKEND_IDS = Object.keys(BACKEND_LABELS);
+function runSpawn(command, args, env, timeoutMs) {
+    try {
+        const result = spawnSync(command, args, {
+            env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: timeoutMs,
+            windowsHide: true,
+        });
+        const stdout = decodeBuffer(result.stdout).trim();
+        const stderr = decodeBuffer(result.stderr).trim();
+        return {
+            exitCode: result.status,
+            ok: !result.error && result.status === 0,
+            stdout,
+            stderr,
+        };
+    }
+    catch {
+        return { exitCode: null, ok: false, stdout: '', stderr: '' };
+    }
+}
+function decodeBuffer(value) {
+    if (!value)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    return value.toString('utf8');
+}
+function unsupportedAction(backendId, action, durationMs) {
+    return {
+        backendId,
+        action,
+        result: 'unsupported',
+        state: 'unsupported',
+        detail: `${BACKEND_LABELS[backendId] ?? backendId} does not support managed lifecycle operations.`,
+        durationMs,
+    };
+}
+function failedAction(backendId, action, detail, durationMs) {
+    return {
+        backendId,
+        action,
+        result: 'failed',
+        state: 'unknown',
+        detail,
+        durationMs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Docker lifecycle
+// ---------------------------------------------------------------------------
+function dockerHibernate(containerId, env, timeoutMs) {
+    const start = Date.now();
+    if (!containerId) {
+        return failedAction('docker', 'hibernate', 'containerId is required for docker hibernate.', 0);
+    }
+    const result = runSpawn('docker', ['pause', containerId], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'docker',
+            action: 'hibernate',
+            result: 'success',
+            state: 'hibernated',
+            detail: `Container ${containerId} paused.`,
+            durationMs,
+        };
+    }
+    return failedAction('docker', 'hibernate', result.stderr || `docker pause failed (exit ${result.exitCode}).`, durationMs);
+}
+function dockerWake(containerId, env, timeoutMs) {
+    const start = Date.now();
+    if (!containerId) {
+        return failedAction('docker', 'wake', 'containerId is required for docker wake.', 0);
+    }
+    const result = runSpawn('docker', ['unpause', containerId], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'docker',
+            action: 'wake',
+            result: 'success',
+            state: 'running',
+            detail: `Container ${containerId} unpaused.`,
+            durationMs,
+        };
+    }
+    return failedAction('docker', 'wake', result.stderr || `docker unpause failed (exit ${result.exitCode}).`, durationMs);
+}
+function dockerStatus(containerId, env, timeoutMs) {
+    const start = Date.now();
+    if (!containerId) {
+        return failedAction('docker', 'status', 'containerId is required for docker status.', 0);
+    }
+    const result = runSpawn('docker', ['inspect', '--format', '{{.State.Status}}', containerId], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (!result.ok) {
+        return failedAction('docker', 'status', result.stderr || `docker inspect failed (exit ${result.exitCode}).`, durationMs);
+    }
+    const raw = result.stdout.trim().toLowerCase();
+    const state = dockerStatusToLifecycleState(raw);
+    return {
+        backendId: 'docker',
+        action: 'status',
+        result: 'success',
+        state,
+        detail: `Container ${containerId} status: ${raw}.`,
+        durationMs,
+    };
+}
+function dockerStatusToLifecycleState(dockerState) {
+    switch (dockerState) {
+        case 'running':
+            return 'running';
+        case 'paused':
+            return 'hibernated';
+        case 'restarting':
+            return 'starting';
+        case 'removing':
+        case 'exited':
+        case 'dead':
+            return 'stopping';
+        default:
+            return 'unknown';
+    }
+}
+// ---------------------------------------------------------------------------
+// SSH lifecycle
+// ---------------------------------------------------------------------------
+function sshHibernate(_sshHost, _env, _timeoutMs) {
+    // SSH "hibernate" = drop connection. We don't manage persistent connections,
+    // so we just report success — the SSH session will close naturally.
+    return {
+        backendId: 'ssh',
+        action: 'hibernate',
+        result: 'success',
+        state: 'hibernated',
+        detail: 'SSH connection released; keepalive stopped.',
+        durationMs: 0,
+    };
+}
+function sshWake(sshHost, env, timeoutMs) {
+    const start = Date.now();
+    if (!sshHost) {
+        return failedAction('ssh', 'wake', 'sshHost is required for SSH wake.', 0);
+    }
+    const result = runSpawn('ssh', ['-T', '-o', 'ConnectTimeout=10', sshHost, 'true'], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'ssh',
+            action: 'wake',
+            result: 'success',
+            state: 'running',
+            detail: `SSH connection to ${sshHost} verified.`,
+            durationMs,
+        };
+    }
+    return failedAction('ssh', 'wake', result.stderr || `SSH connection to ${sshHost} failed (exit ${result.exitCode}).`, durationMs);
+}
+function sshStatus(sshHost, env, timeoutMs) {
+    const start = Date.now();
+    if (!sshHost) {
+        return failedAction('ssh', 'status', 'sshHost is required for SSH status.', 0);
+    }
+    const result = runSpawn('ssh', ['-T', '-o', 'ConnectTimeout=5', sshHost, 'true'], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'ssh',
+            action: 'status',
+            result: 'success',
+            state: 'running',
+            detail: `SSH host ${sshHost} is reachable.`,
+            durationMs,
+        };
+    }
+    return {
+        backendId: 'ssh',
+        action: 'status',
+        result: 'success',
+        state: 'hibernated',
+        detail: `SSH host ${sshHost} is not reachable: ${result.stderr || `exit ${result.exitCode}`}.`,
+        durationMs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Modal lifecycle
+// ---------------------------------------------------------------------------
+function modalHibernate(modalApp, env, timeoutMs) {
+    const start = Date.now();
+    if (!modalApp) {
+        return failedAction('modal', 'hibernate', 'modalApp is required for Modal hibernate.', 0);
+    }
+    const result = runSpawn('modal', ['app', 'stop', modalApp], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'modal',
+            action: 'hibernate',
+            result: 'success',
+            state: 'hibernated',
+            detail: `Modal app ${modalApp} stopped.`,
+            durationMs,
+        };
+    }
+    return failedAction('modal', 'hibernate', result.stderr || `modal app stop failed (exit ${result.exitCode}).`, durationMs);
+}
+function modalWake(modalApp, env, timeoutMs) {
+    const start = Date.now();
+    if (!modalApp) {
+        return failedAction('modal', 'wake', 'modalApp is required for Modal wake.', 0);
+    }
+    const result = runSpawn('modal', ['run', modalApp], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'modal',
+            action: 'wake',
+            result: 'success',
+            state: 'running',
+            detail: `Modal app ${modalApp} started.`,
+            durationMs,
+        };
+    }
+    return failedAction('modal', 'wake', result.stderr || `modal run failed (exit ${result.exitCode}).`, durationMs);
+}
+function modalStatus(modalApp, env, timeoutMs) {
+    const start = Date.now();
+    if (!modalApp) {
+        return failedAction('modal', 'status', 'modalApp is required for Modal status.', 0);
+    }
+    const result = runSpawn('modal', ['app', 'list'], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (!result.ok) {
+        return failedAction('modal', 'status', result.stderr || `modal app list failed (exit ${result.exitCode}).`, durationMs);
+    }
+    const isRunning = result.stdout.includes(modalApp);
+    return {
+        backendId: 'modal',
+        action: 'status',
+        result: 'success',
+        state: isRunning ? 'running' : 'hibernated',
+        detail: isRunning
+            ? `Modal app ${modalApp} appears in app list.`
+            : `Modal app ${modalApp} not found in app list.`,
+        durationMs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Daytona lifecycle
+// ---------------------------------------------------------------------------
+function daytonaHibernate(workspace, env, timeoutMs) {
+    const start = Date.now();
+    if (!workspace) {
+        return failedAction('daytona', 'hibernate', 'daytonaWorkspace is required for Daytona hibernate.', 0);
+    }
+    const result = runSpawn('daytona', ['workspace', 'stop', workspace], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'daytona',
+            action: 'hibernate',
+            result: 'success',
+            state: 'hibernated',
+            detail: `Daytona workspace ${workspace} stopped.`,
+            durationMs,
+        };
+    }
+    return failedAction('daytona', 'hibernate', result.stderr || `daytona workspace stop failed (exit ${result.exitCode}).`, durationMs);
+}
+function daytonaWake(workspace, env, timeoutMs) {
+    const start = Date.now();
+    if (!workspace) {
+        return failedAction('daytona', 'wake', 'daytonaWorkspace is required for Daytona wake.', 0);
+    }
+    const result = runSpawn('daytona', ['workspace', 'start', workspace], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (result.ok) {
+        return {
+            backendId: 'daytona',
+            action: 'wake',
+            result: 'success',
+            state: 'running',
+            detail: `Daytona workspace ${workspace} started.`,
+            durationMs,
+        };
+    }
+    return failedAction('daytona', 'wake', result.stderr || `daytona workspace start failed (exit ${result.exitCode}).`, durationMs);
+}
+function daytonaStatus(workspace, env, timeoutMs) {
+    const start = Date.now();
+    if (!workspace) {
+        return failedAction('daytona', 'status', 'daytonaWorkspace is required for Daytona status.', 0);
+    }
+    const result = runSpawn('daytona', ['workspace', 'list'], env, timeoutMs);
+    const durationMs = Date.now() - start;
+    if (!result.ok) {
+        return failedAction('daytona', 'status', result.stderr || `daytona workspace list failed (exit ${result.exitCode}).`, durationMs);
+    }
+    const isRunning = result.stdout.includes(workspace);
+    return {
+        backendId: 'daytona',
+        action: 'status',
+        result: 'success',
+        state: isRunning ? 'running' : 'hibernated',
+        detail: isRunning
+            ? `Daytona workspace ${workspace} appears in workspace list.`
+            : `Daytona workspace ${workspace} not found in workspace list.`,
+        durationMs,
+    };
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Execute a lifecycle action on a backend.
+ */
+export function executeBackendLifecycleAction(backendId, action, options = {}) {
+    const env = options.env ?? process.env;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (UNSUPPORTED_BACKEND_IDS.has(backendId)) {
+        return unsupportedAction(backendId, action, 0);
+    }
+    if (!BACKEND_LABELS[backendId]) {
+        return failedAction(backendId, action, `Unknown backend: ${backendId}.`, 0);
+    }
+    switch (backendId) {
+        case 'docker': {
+            const containerId = options.containerId ?? env.CODEBUDDY_DOCKER_CONTAINER ?? '';
+            if (action === 'hibernate')
+                return dockerHibernate(containerId, env, timeoutMs);
+            if (action === 'wake')
+                return dockerWake(containerId, env, timeoutMs);
+            return dockerStatus(containerId, env, timeoutMs);
+        }
+        case 'ssh': {
+            const sshHost = options.sshHost
+                ?? env.CODEBUDDY_SSH_HOST
+                ?? env.SSH_HOST
+                ?? env.CODEBUDDY_REMOTE_HOST
+                ?? '';
+            if (action === 'hibernate')
+                return sshHibernate(sshHost, env, timeoutMs);
+            if (action === 'wake')
+                return sshWake(sshHost, env, timeoutMs);
+            return sshStatus(sshHost, env, timeoutMs);
+        }
+        case 'modal': {
+            const modalApp = options.modalApp ?? env.CODEBUDDY_MODAL_APP ?? '';
+            if (action === 'hibernate')
+                return modalHibernate(modalApp, env, timeoutMs);
+            if (action === 'wake')
+                return modalWake(modalApp, env, timeoutMs);
+            return modalStatus(modalApp, env, timeoutMs);
+        }
+        case 'daytona': {
+            const workspace = options.daytonaWorkspace ?? env.CODEBUDDY_DAYTONA_WORKSPACE ?? '';
+            if (action === 'hibernate')
+                return daytonaHibernate(workspace, env, timeoutMs);
+            if (action === 'wake')
+                return daytonaWake(workspace, env, timeoutMs);
+            return daytonaStatus(workspace, env, timeoutMs);
+        }
+        default:
+            return unsupportedAction(backendId, action, 0);
+    }
+}
+/**
+ * Build a lifecycle status report for all backends.
+ */
+export function buildBackendLifecycleStatusReport(options = {}) {
+    const now = options.now ?? (() => new Date());
+    const entries = ALL_BACKEND_IDS.map((backendId) => {
+        const lifecycleSupported = !UNSUPPORTED_BACKEND_IDS.has(backendId);
+        if (!lifecycleSupported) {
+            return {
+                backendId,
+                label: BACKEND_LABELS[backendId] ?? backendId,
+                lifecycleSupported: false,
+                state: 'unsupported',
+                detail: `${BACKEND_LABELS[backendId] ?? backendId} does not support managed lifecycle operations.`,
+            };
+        }
+        const statusAction = executeBackendLifecycleAction(backendId, 'status', options);
+        return {
+            backendId,
+            label: BACKEND_LABELS[backendId] ?? backendId,
+            lifecycleSupported: true,
+            state: statusAction.state,
+            detail: statusAction.detail,
+        };
+    });
+    return {
+        kind: 'hermes_runtime_lifecycle_status',
+        schemaVersion: 1,
+        generatedAt: now().toISOString(),
+        platform: os.platform(),
+        arch: os.arch(),
+        backends: entries,
+    };
+}
+/**
+ * Render a lifecycle status report as human-readable text.
+ */
+export function renderBackendLifecycleStatusReport(report) {
+    const lines = [
+        'Hermes runtime lifecycle status',
+        `Platform: ${report.platform}/${report.arch}`,
+        `Generated: ${report.generatedAt}`,
+        '',
+        'Backends:',
+        ...report.backends.map((entry) => {
+            const supported = entry.lifecycleSupported ? 'lifecycle' : 'no-lifecycle';
+            return `  ${entry.backendId}: ${entry.state} (${supported}) — ${entry.detail}`;
+        }),
+    ];
+    return lines.join('\n');
+}
+/**
+ * Render a single lifecycle action result as human-readable text.
+ */
+export function renderBackendLifecycleAction(action) {
+    const lines = [
+        `Hermes runtime lifecycle ${action.action} (${action.backendId}): ${action.result}`,
+        `  State: ${action.state}`,
+        `  Detail: ${action.detail}`,
+        `  Duration: ${action.durationMs}ms`,
+    ];
+    return lines.join('\n');
+}
+//# sourceMappingURL=hermes-runtime-lifecycle.js.map

package/dist/agent/lesson-auto-proposer.js

@@ -15,6 +15,7 @@
 import { CodeBuddyClient } from '../codebuddy/client.js';
 import { detectProviderFromEnv } from '../utils/provider-detector.js';
 import { getLessonCandidateQueue, } from './lesson-candidate-queue.js';
+import { scanForSecrets } from '../fleet/privacy-lint.js';
 import { logger } from '../utils/logger.js';
 const VALID = ['PATTERN', 'RULE', 'CONTEXT', 'INSIGHT'];
 const SYSTEM_PROMPT = `You extract REUSABLE PROCEDURAL LESSONS from a coding session that just completed.
@@ -98,6 +99,15 @@ export async function proposeLessonsFromSession(chatHistory, workDir = process.c
         const content = (cand.content || '').trim();
         if (!content || !VALID.includes(category))
             continue;
+        // WS3 guard-rail: never persist secrets/PII into memory — even into the
+        // review queue, where a reviewer could approve them into lessons.md.
+        const lint = scanForSecrets(`${content}\n${cand.context ?? ''}`);
+        if (lint.hasSecrets) {
+            logger.warn('[lesson-auto-proposer] candidate dropped: contains secret/PII material', {
+                kinds: lint.matches.map((m) => m.kind),
+            });
+            continue;
+        }
         try {
             const { candidate } = queue.propose({
                 category,

package/dist/agent/middleware/index.d.ts

@@ -18,3 +18,4 @@ export type { AutoRepairConfig } from './auto-repair-middleware.js';
 export { QualityGateMiddleware, createQualityGateMiddleware } from './quality-gate-middleware.js';
 export type { QualityGateConfig, QualityGate } from './quality-gate-middleware.js';
 export { ReasoningMiddleware, createReasoningMiddleware } from './reasoning-middleware.js';
+export { VisualValidationMiddleware } from './visual-validation-middleware.js';

package/dist/agent/middleware/index.js

@@ -14,4 +14,5 @@ export { WorkflowGuardMiddleware } from './workflow-guard.js';
 export { AutoRepairMiddleware, createAutoRepairMiddleware } from './auto-repair-middleware.js';
 export { QualityGateMiddleware, createQualityGateMiddleware } from './quality-gate-middleware.js';
 export { ReasoningMiddleware, createReasoningMiddleware } from './reasoning-middleware.js';
+export { VisualValidationMiddleware } from './visual-validation-middleware.js';
 //# sourceMappingURL=index.js.map

package/dist/agent/middleware/session-duration.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Session Duration Middleware (WS3-T3 — auto-pause & resume)
+ *
+ * Very long sessions (12 h+) degrade context quality and pile up risk.
+ * Past a configurable threshold this middleware suggests a clean pause,
+ * takes a fresh context snapshot as the resume point (WS3-T2), and
+ * reminds periodically instead of nagging every turn.
+ *
+ * It never stops the loop — pausing stays the operator's decision; the
+ * autonomous runner has its own bounded budgets (WS1).
+ *
+ * @module agent/middleware
+ */
+import { ConversationMiddleware, MiddlewareContext, MiddlewareResult } from './types.js';
+export interface SessionDurationOptions {
+    /** Pause-suggestion threshold in ms. Default: CODEBUDDY_SESSION_PAUSE_HOURS (12 h); 0 disables. */
+    maxSessionMs?: number;
+    /** Re-warn cadence once past the threshold. Default 60 min. */
+    remindEveryMs?: number;
+    /** Injectable clock for tests. */
+    now?: () => number;
+    /** Take a fresh context snapshot when the pause is suggested (WS3-T2 hook). */
+    takeSnapshot?: () => void;
+}
+export declare class SessionDurationMiddleware implements ConversationMiddleware {
+    readonly name = "session-duration";
+    readonly priority = 35;
+    private readonly startedAt;
+    private readonly thresholdMs;
+    private readonly remindEveryMs;
+    private readonly now;
+    private readonly takeSnapshot;
+    private lastWarnedAt;
+    constructor(options?: SessionDurationOptions);
+    beforeTurn(_context: MiddlewareContext): MiddlewareResult;
+}

package/dist/agent/middleware/session-duration.js

@@ -0,0 +1,78 @@
+/**
+ * Session Duration Middleware (WS3-T3 — auto-pause & resume)
+ *
+ * Very long sessions (12 h+) degrade context quality and pile up risk.
+ * Past a configurable threshold this middleware suggests a clean pause,
+ * takes a fresh context snapshot as the resume point (WS3-T2), and
+ * reminds periodically instead of nagging every turn.
+ *
+ * It never stops the loop — pausing stays the operator's decision; the
+ * autonomous runner has its own bounded budgets (WS1).
+ *
+ * @module agent/middleware
+ */
+import { RunStore } from '../../observability/run-store.js';
+import { logger } from '../../utils/logger.js';
+const HOUR_MS = 3_600_000;
+function defaultThresholdMs() {
+    const hours = parseFloat(process.env.CODEBUDDY_SESSION_PAUSE_HOURS || '12');
+    if (!Number.isFinite(hours) || hours <= 0)
+        return 0; // 0/invalid → disabled
+    return hours * HOUR_MS;
+}
+export class SessionDurationMiddleware {
+    name = 'session-duration';
+    priority = 35;
+    startedAt;
+    thresholdMs;
+    remindEveryMs;
+    now;
+    takeSnapshot;
+    lastWarnedAt = null;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+        this.startedAt = this.now();
+        this.thresholdMs = options.maxSessionMs ?? defaultThresholdMs();
+        this.remindEveryMs = options.remindEveryMs ?? HOUR_MS;
+        this.takeSnapshot = options.takeSnapshot;
+    }
+    beforeTurn(_context) {
+        if (this.thresholdMs <= 0)
+            return { action: 'continue' };
+        const elapsed = this.now() - this.startedAt;
+        if (elapsed < this.thresholdMs)
+            return { action: 'continue' };
+        if (this.lastWarnedAt !== null && this.now() - this.lastWarnedAt < this.remindEveryMs) {
+            return { action: 'continue' };
+        }
+        this.lastWarnedAt = this.now();
+        // Fresh resume point right when the pause is suggested.
+        try {
+            this.takeSnapshot?.();
+        }
+        catch (err) {
+            logger.debug('[session-duration] snapshot on pause suggestion failed', { error: String(err) });
+        }
+        try {
+            const runStore = RunStore.getInstance();
+            if (runStore.getCurrentRunId()) {
+                runStore.appendEvent('pause_suggested', {
+                    elapsedMs: elapsed,
+                    thresholdMs: this.thresholdMs,
+                });
+            }
+        }
+        catch {
+            // Observability must never break the loop.
+        }
+        const hours = (elapsed / HOUR_MS).toFixed(1);
+        return {
+            action: 'warn',
+            message: `⏸️ Session running for ${hours} h. Consider a clean pause: a fresh context ` +
+                `snapshot was just written (.codebuddy/context-snapshot.json), a handoff is ` +
+                `written on exit (.codebuddy/HANDOFF.md), and \`buddy --continue\` reloads the ` +
+                `session. Long sessions degrade context quality — \`/compact\` also helps.`,
+        };
+    }
+}
+//# sourceMappingURL=session-duration.js.map

package/dist/agent/middleware/visual-validation-middleware.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Visual Validation Middleware
+ *
+ * Checks if the agent has saved an Office document (Excel, PowerPoint, Word).
+ * If so, it warns the agent to consider running a visual validation step
+ * using `snapshot_with_screenshot` to verify the layout, fonts, and alignments.
+ *
+ * Priority 156
+ */
+import type { ConversationMiddleware, MiddlewareContext, MiddlewareResult } from './types.js';
+export declare class VisualValidationMiddleware implements ConversationMiddleware {
+    readonly name = "visual-validation";
+    readonly priority = 156;
+    private hasWarnedForFiles;
+    afterTurn(context: MiddlewareContext): Promise<MiddlewareResult>;
+    private getRecentlySavedOfficeFiles;
+}