@diyor28/qa-core 0.1.0

package/dist/runner.js

@@ -0,0 +1,143 @@
+import { BrowserController } from './browser/controller.js';
+import { VisionAnalyzer } from './vision/analyzer.js';
+import { AgentLoop } from './agent/loop.js';
+import { ReportBuilder } from './report/builder.js';
+import { readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+export class QaRunner {
+    config;
+    browserController = null;
+    visionAnalyzer = null;
+    constructor(config) {
+        this.config = config;
+    }
+    async run() {
+        const startTime = Date.now();
+        try {
+            // Initialize components
+            this.emitProgress('step_started', { step: 'initialization', message: 'Initializing QA runner' });
+            this.browserController = new BrowserController({
+                headless: this.config.browser.headless,
+                viewport: this.config.browser.viewport,
+                enableTrace: this.config.browser.enableTrace,
+                traceDir: this.config.browser.traceDir,
+            });
+            this.visionAnalyzer = new VisionAnalyzer(this.config.models.geminiApiKey);
+            await this.browserController.launch();
+            this.emitProgress('step_completed', { step: 'initialization', message: 'Browser launched successfully' });
+            // Run agent loop
+            this.emitProgress('step_started', { step: 'execution', message: 'Starting test execution' });
+            const agentLoop = new AgentLoop({
+                cerebrasApiKey: this.config.models.cerebrasApiKey,
+                browserController: this.browserController,
+                visionAnalyzer: this.visionAnalyzer,
+                scenarioName: this.config.scenario.name,
+                scenarioContent: this.config.scenario.content,
+                baseUrl: this.config.baseUrl,
+                defectsToCheck: this.config.defectsToCheck || ['Visual overflow', 'Bad UX', 'Poor contrast'],
+                maxIterations: this.config.maxIterations,
+                onProgress: this.config.onProgress,
+            });
+            const agentResult = await agentLoop.run();
+            this.emitProgress('step_completed', {
+                step: 'execution',
+                message: 'Test execution completed',
+                findings: agentResult.findings.length,
+            });
+            // Collect artifacts
+            this.emitProgress('step_started', { step: 'artifacts', message: 'Collecting artifacts' });
+            const artifacts = [];
+            // Add all screenshots from browser controller
+            const screenshots = this.browserController.getAllScreenshots();
+            for (const screenshot of screenshots) {
+                artifacts.push({
+                    type: 'screenshot',
+                    name: screenshot.name,
+                    data: screenshot.buffer,
+                    contentType: 'image/png',
+                });
+            }
+            // Add trace file if enabled
+            if (this.config.browser.enableTrace && this.config.browser.traceDir) {
+                try {
+                    const traceFiles = readdirSync(this.config.browser.traceDir).filter((f) => f.startsWith('trace-'));
+                    if (traceFiles.length > 0) {
+                        // Get the most recent trace file
+                        const latestTrace = traceFiles.sort().pop();
+                        const tracePath = join(this.config.browser.traceDir, latestTrace);
+                        const traceBuffer = readFileSync(tracePath);
+                        artifacts.push({
+                            type: 'trace',
+                            name: latestTrace,
+                            data: traceBuffer,
+                            contentType: 'application/zip',
+                        });
+                    }
+                }
+                catch (error) {
+                    console.warn('[QaRunner] Failed to collect trace file:', error);
+                }
+            }
+            this.emitProgress('step_completed', {
+                step: 'artifacts',
+                message: 'Artifacts collected',
+                count: artifacts.length,
+            });
+            // Build report
+            const duration = Date.now() - startTime;
+            const report = ReportBuilder.buildReport({
+                findings: agentResult.findings,
+                artifacts,
+                metadata: {
+                    scenarioName: this.config.scenario.name,
+                    baseUrl: this.config.baseUrl,
+                    viewport: this.config.browser.viewport,
+                    timestamp: new Date().toISOString(),
+                },
+                duration,
+                summary: agentResult.summary,
+            });
+            return report;
+        }
+        catch (error) {
+            console.error('[QaRunner] Error during test execution:', error);
+            // Build error report
+            const duration = Date.now() - startTime;
+            return ReportBuilder.buildReport({
+                findings: [
+                    {
+                        severity: 'critical',
+                        title: 'Test execution failed',
+                        description: `Error during test execution: ${error instanceof Error ? error.message : String(error)}`,
+                        reproSteps: ['Test runner encountered an error'],
+                        category: 'functional',
+                    },
+                ],
+                artifacts: [],
+                metadata: {
+                    scenarioName: this.config.scenario.name,
+                    baseUrl: this.config.baseUrl,
+                    viewport: this.config.browser.viewport,
+                    timestamp: new Date().toISOString(),
+                },
+                duration,
+                summary: `Test execution failed: ${error instanceof Error ? error.message : String(error)}`,
+            });
+        }
+        finally {
+            // Always close browser
+            if (this.browserController) {
+                await this.browserController.close();
+            }
+        }
+    }
+    emitProgress(type, data) {
+        if (this.config.onProgress) {
+            this.config.onProgress({
+                type,
+                data,
+                timestamp: Date.now(),
+            });
+        }
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,69 @@
+export interface QaScenario {
+    name: string;
+    content: string;
+}
+export interface QaFinding {
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    title: string;
+    description: string;
+    reproSteps: string[];
+    expected?: string;
+    actual?: string;
+    screenshotName?: string;
+    category: 'functional' | 'ux' | 'ui' | 'accessibility';
+}
+export interface QaArtifact {
+    type: 'screenshot' | 'trace';
+    name: string;
+    data: Buffer;
+    contentType: string;
+}
+export interface QaReport {
+    summary: string;
+    status: 'passed' | 'failed' | 'issues_found';
+    duration: number;
+    findings: QaFinding[];
+    artifacts: QaArtifact[];
+    metadata: {
+        scenarioName: string;
+        baseUrl: string;
+        viewport: {
+            width: number;
+            height: number;
+        };
+        timestamp: string;
+    };
+}
+export interface QaProgressEvent {
+    type: 'step_started' | 'step_completed' | 'screenshot_captured' | 'finding_discovered' | 'context_usage';
+    data: Record<string, unknown>;
+    timestamp: number;
+}
+export interface ScreenshotEntry {
+    timestamp: number;
+    name: string;
+    buffer: Buffer;
+    context: string;
+    url: string;
+}
+export interface QaRunnerConfig {
+    browser: {
+        headless?: boolean;
+        viewport: {
+            width: number;
+            height: number;
+        };
+        enableTrace?: boolean;
+        traceDir?: string;
+    };
+    models: {
+        cerebrasApiKey: string;
+        geminiApiKey: string;
+    };
+    baseUrl: string;
+    scenario: QaScenario;
+    defectsToCheck?: string[];
+    maxIterations?: number;
+    onProgress?: (event: QaProgressEvent) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,KAAK,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;IACjD,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,YAAY,GAAG,IAAI,GAAG,IAAI,GAAG,eAAe,CAAC;CACxD;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,QAAQ,GAAG,QAAQ,GAAG,cAAc,CAAC;IAC7C,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,SAAS,EAAE,UAAU,EAAE,CAAC;IACxB,QAAQ,EAAE;QACR,YAAY,EAAE,MAAM,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,QAAQ,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;QAC5C,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC;CACH;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,cAAc,GAAG,gBAAgB,GAAG,qBAAqB,GAAG,oBAAoB,GAAG,eAAe,CAAC;IACzG,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE;QACP,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,QAAQ,EAAE;YAAE,KAAK,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC;QAC5C,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,MAAM,EAAE;QACN,cAAc,EAAE,MAAM,CAAC;QACvB,YAAY,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,UAAU,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC;CAC/C"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vision/analyzer.d.ts

@@ -0,0 +1,8 @@
+import type { QaFinding } from '../types.js';
+export declare class VisionAnalyzer {
+    private genAI;
+    private model;
+    constructor(apiKey: string);
+    analyzeScreenshot(screenshot: Buffer, context: string, url: string): Promise<QaFinding[]>;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/vision/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../src/vision/analyzer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAG7C,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAqB;IAClC,OAAO,CAAC,KAAK,CAAM;gBAEP,MAAM,EAAE,MAAM;IAOpB,iBAAiB,CACrB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,SAAS,EAAE,CAAC;CAyCxB"}

package/dist/vision/analyzer.js

@@ -0,0 +1,49 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { buildVisionPrompt } from './prompts.js';
+export class VisionAnalyzer {
+    genAI;
+    model;
+    constructor(apiKey) {
+        this.genAI = new GoogleGenerativeAI(apiKey);
+        this.model = this.genAI.getGenerativeModel({
+            model: 'gemini-3-flash-preview',
+        });
+    }
+    async analyzeScreenshot(screenshot, context, url) {
+        try {
+            const base64Image = screenshot.toString('base64');
+            const prompt = buildVisionPrompt(context, url);
+            const result = await this.model.generateContent([
+                {
+                    inlineData: {
+                        mimeType: 'image/png',
+                        data: base64Image,
+                    },
+                },
+                { text: prompt },
+            ]);
+            const response = await result.response;
+            const text = response.text();
+            // Parse JSON response
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                console.warn('[VisionAnalyzer] No JSON found in response:', text);
+                return [];
+            }
+            const parsed = JSON.parse(jsonMatch[0]);
+            const findings = parsed.findings || [];
+            // Convert vision findings to QaFinding format
+            return findings.map((finding) => ({
+                severity: finding.severity || 'medium',
+                title: finding.title,
+                description: `${finding.description}\n\nSuggestion: ${finding.suggestion || 'N/A'}`,
+                reproSteps: [`Screenshot captured at: ${url}`, `Context: ${context}`],
+                category: finding.category,
+            }));
+        }
+        catch (error) {
+            console.error('[VisionAnalyzer] Error analyzing screenshot:', error);
+            return [];
+        }
+    }
+}

package/dist/vision/prompts.d.ts

@@ -0,0 +1,2 @@
+export declare function buildVisionPrompt(context: string, url: string): string;
+//# sourceMappingURL=prompts.d.ts.map

package/dist/vision/prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompts.d.ts","sourceRoot":"","sources":["../../src/vision/prompts.ts"],"names":[],"mappings":"AAAA,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CA2BtE"}

package/dist/vision/prompts.js

@@ -0,0 +1,28 @@
+export function buildVisionPrompt(context, url) {
+    return `You are a ruthless UX/UI critic analyzing a screenshot of a web application.
+
+Context: ${context}
+URL: ${url}
+
+Analyze this screenshot for:
+- Visual overflow (content cut off, horizontal scroll)
+- Poor color contrast (WCAG AA violations)
+- Bad UX (confusing navigation, hidden CTAs, poor hierarchy)
+- Accessibility issues (missing labels, poor focus indicators)
+
+Return findings as JSON array with structure:
+{
+  "findings": [
+    {
+      "category": "ux" | "ui" | "accessibility",
+      "severity": "low" | "medium" | "high",
+      "title": "Short title",
+      "description": "Detailed description",
+      "suggestion": "How to fix"
+    }
+  ]
+}
+
+Be concise and specific. Only report actual issues you can clearly see in the screenshot.
+If everything looks good, return an empty findings array.`;
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@diyor28/qa-core",
+  "version": "0.1.0",
+  "private": false,
+  "description": "Core library for AI-powered browser testing with Playwright, GLM-4.7, and Gemini vision analysis",
+  "keywords": [
+    "qa",
+    "testing",
+    "playwright",
+    "ai",
+    "browser-automation",
+    "e2e"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/iota-uz/foundry.git",
+    "directory": "packages/qa-core"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@ai-sdk/openai": "^1.0.10",
+    "@google/generative-ai": "^0.21.0",
+    "ai": "^4.0.61",
+    "playwright": "^1.49.0",
+    "zod": "^3.24.1",
+    "@diyor28/context": "1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.5",
+    "typescript": "^5.3.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/agent/context/codecs/browser-state.codec.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import type { BlockCodec, RenderedContent, ContextBlock } from '@diyor28/context';
+import { defaultHash, sortObjectKeys } from '@diyor28/context';
+
+export const BrowserStatePayloadSchema = z.object({
+  currentUrl: z.string(),
+  viewport: z.object({
+    width: z.number(),
+    height: z.number(),
+  }),
+  screenshotCount: z.number(),
+});
+
+export type BrowserStatePayload = z.infer<typeof BrowserStatePayloadSchema>;
+
+export const BrowserStateCodec: BlockCodec<BrowserStatePayload> = {
+  codecId: 'qa:browser-state',
+  version: '1.0.0',
+  payloadSchema: BrowserStatePayloadSchema,
+
+  canonicalize(payload: BrowserStatePayload): unknown {
+    return sortObjectKeys(payload);
+  },
+
+  hash(canonicalized: unknown): string {
+    return defaultHash(canonicalized);
+  },
+
+  render(block: ContextBlock<BrowserStatePayload>): RenderedContent {
+    const { currentUrl, viewport, screenshotCount } = block.payload;
+
+    const content = `## Browser State
+
+Current URL: ${currentUrl}
+Viewport: ${viewport.width}x${viewport.height}
+Screenshots captured: ${screenshotCount}`;
+
+    return {
+      anthropic: {
+        role: 'user',
+        content: [
+          {
+            type: 'text',
+            text: content,
+            cache_control: { type: 'ephemeral' }, // State blocks use ephemeral cache
+          },
+        ],
+      },
+      openai: { role: 'user', content },
+      gemini: { role: 'user', parts: [{ text: content }] },
+    };
+  },
+
+  validate(payload: unknown): BrowserStatePayload {
+    return BrowserStatePayloadSchema.parse(payload);
+  },
+};

package/src/agent/context/codecs/index.ts

@@ -0,0 +1,2 @@
+export { QaScenarioCodec, QaScenarioPayloadSchema, type QaScenarioPayload } from './qa-scenario.codec.js';
+export { BrowserStateCodec, BrowserStatePayloadSchema, type BrowserStatePayload } from './browser-state.codec.js';

package/src/agent/context/codecs/qa-scenario.codec.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import type { BlockCodec, RenderedContent, ContextBlock } from '@diyor28/context';
+import { defaultHash, sortObjectKeys } from '@diyor28/context';
+
+export const QaScenarioPayloadSchema = z.object({
+  scenarioName: z.string(),
+  instructions: z.string(),
+  baseUrl: z.string().url(),
+  defectsToCheck: z.array(z.string()),
+});
+
+export type QaScenarioPayload = z.infer<typeof QaScenarioPayloadSchema>;
+
+export const QaScenarioCodec: BlockCodec<QaScenarioPayload> = {
+  codecId: 'qa:scenario',
+  version: '1.0.0',
+  payloadSchema: QaScenarioPayloadSchema,
+
+  canonicalize(payload: QaScenarioPayload): unknown {
+    return sortObjectKeys({
+      scenarioName: payload.scenarioName.trim(),
+      instructions: payload.instructions.trim(),
+      baseUrl: payload.baseUrl,
+      defectsToCheck: [...payload.defectsToCheck].sort(),
+    });
+  },
+
+  hash(canonicalized: unknown): string {
+    return defaultHash(canonicalized);
+  },
+
+  render(block: ContextBlock<QaScenarioPayload>): RenderedContent {
+    const { scenarioName, instructions, baseUrl, defectsToCheck } = block.payload;
+
+    const content = `# Test Scenario: ${scenarioName}
+
+**Target URL:** ${baseUrl}
+
+## Instructions
+${instructions}
+
+## Defects to Check
+${defectsToCheck.map((d) => `- ${d}`).join('\n')}`;
+
+    return {
+      anthropic: { role: 'user', content },
+      openai: { role: 'user', content },
+      gemini: { role: 'user', parts: [{ text: content }] },
+    };
+  },
+
+  validate(payload: unknown): QaScenarioPayload {
+    return QaScenarioPayloadSchema.parse(payload);
+  },
+};

package/src/agent/context/index.ts

@@ -0,0 +1,3 @@
+export { QaContextService, type BuildQaContextOptions } from './qa-context.service.js';
+export { QA_POLICY } from './qa-policy.js';
+export * from './codecs/index.js';

package/src/agent/context/qa-context.service.ts

@@ -0,0 +1,90 @@
+import {
+  ContextBuilder,
+  type ContextPolicy,
+  type OpenAICompiledContext,
+  type BlockCodec,
+  compileOpenAIContext,
+  OpenAITokenEstimator,
+  ConversationHistoryCodec,
+  type ConversationMessage,
+  SystemRulesCodec,
+} from '@diyor28/context';
+import { QaScenarioCodec, BrowserStateCodec } from './codecs/index.js';
+import { QA_POLICY } from './qa-policy.js';
+
+export interface BuildQaContextOptions {
+  scenarioName: string;
+  scenarioInstructions: string;
+  baseUrl: string;
+  defectsToCheck: string[];
+  browserState: {
+    currentUrl: string;
+    viewport: { width: number; height: number };
+    screenshotCount: number;
+  };
+  conversationHistory: ConversationMessage[];
+  systemPrompt: string;
+}
+
+export class QaContextService {
+  private readonly tokenEstimator: OpenAITokenEstimator;
+  private readonly codecRegistry: Map<string, BlockCodec<unknown>>;
+
+  constructor() {
+    // OpenAI token estimator (compatible with Cerebras/GLM-4.7)
+    this.tokenEstimator = new OpenAITokenEstimator('gpt-4');
+
+    // Build codec registry
+    this.codecRegistry = new Map<string, BlockCodec<unknown>>([
+      [SystemRulesCodec.codecId, SystemRulesCodec as BlockCodec<unknown>],
+      [QaScenarioCodec.codecId, QaScenarioCodec as BlockCodec<unknown>],
+      [BrowserStateCodec.codecId, BrowserStateCodec as BlockCodec<unknown>],
+      [ConversationHistoryCodec.codecId, ConversationHistoryCodec as BlockCodec<unknown>],
+    ]);
+  }
+
+  async buildContext(options: BuildQaContextOptions): Promise<OpenAICompiledContext> {
+    const builder = new ContextBuilder();
+
+    // System prompt (pinned - always at top)
+    builder.system({
+      text: options.systemPrompt,
+      cacheable: false, // OpenAI doesn't have prompt caching yet
+    });
+
+    // QA scenario (reference - test instructions)
+    builder.reference(QaScenarioCodec, {
+      scenarioName: options.scenarioName,
+      instructions: options.scenarioInstructions,
+      baseUrl: options.baseUrl,
+      defectsToCheck: options.defectsToCheck,
+    });
+
+    // Browser state (state - current browser info)
+    builder.state(BrowserStateCodec, options.browserState);
+
+    // Conversation history (if any)
+    if (options.conversationHistory.length > 0) {
+      builder.history(options.conversationHistory);
+    }
+
+    // Get graph and create view
+    const graph = builder.getGraph();
+    const maxTokens = QA_POLICY.contextWindow - QA_POLICY.completionReserve;
+
+    const view = await graph.createView({
+      tokenEstimator: this.tokenEstimator,
+      maxTokens,
+    });
+
+    // Compile to OpenAI format
+    const compiled = compileOpenAIContext([...view.blocks], QA_POLICY, {
+      codecRegistry: this.codecRegistry,
+    });
+
+    // Log context usage (for observability)
+    console.log(`[QA Context] Tokens: ${compiled.estimatedTokens}, Blocks: ${view.blocks.length}`);
+
+    return compiled;
+  }
+}

package/src/agent/context/qa-policy.ts

@@ -0,0 +1,54 @@
+import type { ContextPolicy } from '@diyor28/context';
+
+/**
+ * QA Context Policy
+ *
+ * Defines context management strategy for QA agent execution.
+ * Optimized for browser automation with tool outputs and screenshot management.
+ *
+ * ## Context Structure
+ *
+ * 1. System prompt (pinned)
+ * 2. QA scenario (reference - test instructions)
+ * 3. Browser state (state - current URL, viewport)
+ * 4. Tool outputs (tool_output - navigation, clicks, screenshots)
+ * 5. Conversation history (history - agent reasoning)
+ *
+ * ## Compaction Triggers
+ *
+ * When context exceeds available tokens:
+ * - Old tool outputs are pruned (keep last 5)
+ * - History is summarized
+ * - State blocks are never truncated
+ */
+export const QA_POLICY: ContextPolicy = {
+  provider: 'openai', // Cerebras is OpenAI-compatible
+  modelId: 'glm-4.7', // GLM-4.7 via Cerebras
+
+  contextWindow: 200_000, // GLM-4.7 context window
+  completionReserve: 8_000, // Reserve for agent response
+
+  overflowStrategy: 'compact', // Auto-compact old tool outputs
+
+  kindPriorities: [
+    { kind: 'pinned', minTokens: 500, maxTokens: 2000, truncatable: false },
+    { kind: 'reference', minTokens: 500, maxTokens: 3000, truncatable: false },
+    { kind: 'state', minTokens: 200, maxTokens: 1000, truncatable: false },
+    { kind: 'tool_output', minTokens: 1000, maxTokens: 50000, truncatable: true },
+    { kind: 'history', minTokens: 2000, maxTokens: 100000, truncatable: true },
+    { kind: 'turn', minTokens: 500, maxTokens: 5000, truncatable: false },
+  ],
+
+  compaction: {
+    pruneToolOutputs: true,
+    maxToolOutputAge: 3600, // 1 hour
+    maxToolOutputsPerKind: 5, // Keep last 5 tool outputs
+    summarizeHistory: true,
+    maxHistoryMessages: 20, // Keep last 20 turns
+  },
+
+  sensitivity: {
+    maxSensitivity: 'public',
+    redactRestricted: true,
+  },
+};