@taodigital/agents 0.0.0-stage → 1.2.0

package/dist/healing-agent.d.ts

@@ -0,0 +1,73 @@
+/**
+ * ZeTa-AI Self-Healing Agent
+ *
+ * When a test fails because an element can't be found, this agent:
+ * 1. Builds a multi-signal fingerprint of every element during crawl.
+ * 2. On failure, searches the fresh page scan using all fingerprint signals.
+ * 3. Finds the best match, scores confidence, updates the test.
+ * 4. Routes to human review if confidence is too low.
+ *
+ * This makes ZeTa-AI tests far more durable than competitors — tests
+ * don't break when the app changes slightly.
+ */
+export interface ElementSelector {
+    type: 'text' | 'aria-label' | 'role' | 'css' | 'position' | 'placeholder';
+    value: string;
+    confidence: number;
+}
+export interface HealingResult {
+    healed: boolean;
+    confidence: number;
+    matchedSelector?: ElementSelector;
+    reasoning: string;
+    needsHumanReview: boolean;
+    updatedTest?: {
+        elementMeaning: string;
+        newSelector: ElementSelector;
+    };
+    healCandidate?: {
+        elementMeaning: string;
+        newSelector: ElementSelector;
+    };
+}
+/**
+ * Build a multi-signal fingerprint for an element during crawl.
+ * Called after readScreen() to enrich each element with stable selectors.
+ */
+export declare function buildFingerprint(rawElement: {
+    label?: string;
+    role: string;
+    ariaLabel?: string;
+    placeholder?: string;
+    cssSelector?: string;
+    textContent?: string;
+    position?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+}): ElementSelector[];
+/**
+ * Attempt to heal a failed element lookup using AI.
+ * Called when a test step fails because an element wasn't found.
+ */
+export declare function healElement(opts: {
+    tenantId: string;
+    projectId: string;
+    /** Omit when the caller has no crawl-time Element record for this step (e.g. an
+     *  execution plan generated straight from a natural-language test case) — healing
+     *  still works from currentPageElements alone, just without fingerprint history. */
+    elementId?: string;
+    failedElementMeaning: string;
+    currentPageElements: Array<{
+        meaning: string;
+        role: string;
+        ariaLabel?: string;
+        textContent?: string;
+    }>;
+    /** Override the module-level HEALING_REQUIRE_APPROVAL env var for this call.
+     *  When true, healing is NOT auto-applied — the candidate is returned in
+     *  healCandidate for engineer review. Defaults to HEALING_REQUIRE_APPROVAL. */
+    requireApproval?: boolean;
+}): Promise<HealingResult>;

package/dist/healing-agent.js

@@ -0,0 +1,137 @@
+"use strict";
+/**
+ * ZeTa-AI Self-Healing Agent
+ *
+ * When a test fails because an element can't be found, this agent:
+ * 1. Builds a multi-signal fingerprint of every element during crawl.
+ * 2. On failure, searches the fresh page scan using all fingerprint signals.
+ * 3. Finds the best match, scores confidence, updates the test.
+ * 4. Routes to human review if confidence is too low.
+ *
+ * This makes ZeTa-AI tests far more durable than competitors — tests
+ * don't break when the app changes slightly.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFingerprint = buildFingerprint;
+exports.healElement = healElement;
+const app_brain_1 = require("@taodigital/app-brain");
+const core_1 = require("@taodigital/core");
+const llm_js_1 = require("./llm.js");
+const llm_config_js_1 = require("./llm-config.js");
+const HEALING_CONFIDENCE_THRESHOLD = parseInt(process.env.HEALING_CONFIDENCE_THRESHOLD ?? '') || 70;
+const HEALING_REQUIRE_APPROVAL = process.env.HEALING_REQUIRE_APPROVAL === 'true';
+/**
+ * Build a multi-signal fingerprint for an element during crawl.
+ * Called after readScreen() to enrich each element with stable selectors.
+ */
+function buildFingerprint(rawElement) {
+    const selectors = [];
+    if (rawElement.ariaLabel) {
+        selectors.push({ type: 'aria-label', value: rawElement.ariaLabel, confidence: 0.95 });
+    }
+    if (rawElement.label && rawElement.label !== '(unlabeled)') {
+        selectors.push({ type: 'text', value: rawElement.label, confidence: 0.85 });
+    }
+    if (rawElement.placeholder) {
+        selectors.push({ type: 'placeholder', value: rawElement.placeholder, confidence: 0.80 });
+    }
+    if (rawElement.textContent) {
+        selectors.push({ type: 'text', value: rawElement.textContent.slice(0, 100), confidence: 0.75 });
+    }
+    if (rawElement.role) {
+        selectors.push({ type: 'role', value: rawElement.role, confidence: 0.60 });
+    }
+    if (rawElement.cssSelector) {
+        selectors.push({ type: 'css', value: rawElement.cssSelector, confidence: 0.40 });
+    }
+    return selectors.sort((a, b) => b.confidence - a.confidence);
+}
+/**
+ * Attempt to heal a failed element lookup using AI.
+ * Called when a test step fails because an element wasn't found.
+ */
+async function healElement(opts) {
+    const fingerprint = opts.elementId ? await app_brain_1.AppBrain.getElementFingerprint(opts.tenantId, opts.elementId) : null;
+    // Pre-rank elements by semantic relevance — keeps LLM prompt focused when page has many elements
+    let candidateElements = opts.currentPageElements;
+    const MAX_ELEMENTS_IN_PROMPT = 15;
+    if (candidateElements.length > MAX_ELEMENTS_IN_PROMPT) {
+        try {
+            const texts = candidateElements.map((e) => `${e.meaning} ${e.role} ${e.ariaLabel ?? ''}`.trim());
+            const ranked = await (0, app_brain_1.rerankStrings)(opts.failedElementMeaning, texts, MAX_ELEMENTS_IN_PROMPT, 0);
+            candidateElements = ranked.map(({ index }) => opts.currentPageElements[index]);
+        }
+        catch {
+            candidateElements = candidateElements.slice(0, MAX_ELEMENTS_IN_PROMPT);
+        }
+    }
+    const SYSTEM_DEFAULT = [
+        'You are ZeTa-AI\'s Self-Healing Agent.',
+        'A test failed because a UI element could not be found.',
+        'Find the element on the current page that BEST MATCHES the failed element.',
+        'Return JSON only: { found, matchedMeaning, confidence, reasoning, needsHuman }',
+    ].join(' ');
+    const system = await (0, core_1.getAgentPrompt)('healing-element', undefined, opts.tenantId) ?? SYSTEM_DEFAULT;
+    const user = [
+        `FAILED ELEMENT: "${opts.failedElementMeaning}"`,
+        fingerprint
+            ? `KNOWN FINGERPRINT: ${JSON.stringify(fingerprint.selectors, null, 2)}`
+            : 'No fingerprint stored yet.',
+        '',
+        'CURRENT PAGE ELEMENTS:',
+        candidateElements.map((e) => `- "${e.meaning}" [${e.role}]${e.ariaLabel ? ` aria="${e.ariaLabel}"` : ''}`).join('\n'),
+        '',
+        'Find the best match. If confidence < 70, set needsHuman: true.',
+    ].join('\n');
+    // ZETA-166: enforce token budget and use tenant-configured LLM (testRunner is the closest task type)
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(opts.tenantId, 'testRunner');
+    let result;
+    try {
+        const seed = (0, llm_js_1.deterministicSeed)(`${opts.tenantId}:${opts.projectId}:heal:${opts.failedElementMeaning.slice(0, 200)}`);
+        const { text: raw } = await (0, llm_js_1.askTracked)(system, user, llmCfg, undefined, undefined, { temperature: 0, seed });
+        const json = raw.slice(raw.indexOf('{'), raw.lastIndexOf('}') + 1);
+        result = JSON.parse(json);
+    }
+    catch {
+        return {
+            healed: false,
+            confidence: 0,
+            reasoning: 'Healing agent failed to parse response.',
+            needsHumanReview: true,
+        };
+    }
+    const approvalRequired = opts.requireApproval ?? HEALING_REQUIRE_APPROVAL;
+    if (result.found && result.confidence >= HEALING_CONFIDENCE_THRESHOLD) {
+        // Update the fingerprint's heal count and flakiness stats only when auto-healing.
+        if (fingerprint && opts.elementId && !approvalRequired) {
+            await app_brain_1.AppBrain.recordElementHeal(opts.tenantId, opts.elementId);
+            // Refresh LOCATOR_STRATEGY with updated self-healing data (GAP-SF-19)
+            const { refreshLocatorStrategyWithHealingData } = await import('./skill-file-agent.js');
+            refreshLocatorStrategyWithHealingData(opts.tenantId, opts.projectId).catch(console.error);
+            // TODO: track healing as a flakiness event once AppBrain.recordFlakinessOutcome
+            // accepts a testCaseId derived from the healed element — requires AppBrain schema
+            // addition to link elementId → testCaseId before this call is useful.
+        }
+        return {
+            healed: !approvalRequired,
+            confidence: result.confidence,
+            reasoning: result.reasoning,
+            needsHumanReview: approvalRequired,
+            updatedTest: !approvalRequired ? {
+                elementMeaning: result.matchedMeaning,
+                newSelector: { type: 'text', value: result.matchedMeaning, confidence: result.confidence / 100 },
+            } : undefined,
+            // When approval required, surface the candidate for the engineer to review
+            healCandidate: approvalRequired ? {
+                elementMeaning: result.matchedMeaning,
+                newSelector: { type: 'text', value: result.matchedMeaning, confidence: result.confidence / 100 },
+            } : undefined,
+        };
+    }
+    return {
+        healed: false,
+        confidence: result.confidence,
+        reasoning: result.reasoning,
+        needsHumanReview: result.needsHuman || result.confidence < HEALING_CONFIDENCE_THRESHOLD,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,36 @@
+export type { GenerateTestCasesOpts, GenerateTestCasesResult, RegenerateTestCaseTitleOpts, TestGenerationAgent, GenerateTestDataOpts, GenerateTestDataBatchCase, GenerateTestDataBatchOpts, GenerateTestDataResult, TestDataAgent, GenerateTestScriptOpts, GenerateTestScriptResult, GenerateSuiteScriptOpts, GenerateSuiteScriptResult, ScriptAgent, GenerateScenariosOpts, ScenarioAgent, ConvertNlpToTestOpts, ConvertNlpToTestResult, NlpAgent, SkillFileAgent, } from './types.js';
+export * from './test-case-agent.js';
+export * from './test-script-agent.js';
+export * from './data-agent.js';
+export * from './field-detector-agent.js';
+export * from './script-agent.js';
+export * from './nlp-agent.js';
+export * from './healing-agent.js';
+export * from './visual-agent.js';
+export * from './skill-file-agent.js';
+export * from './plan-agent.js';
+export * from './llm.js';
+export * from './llm-mock.js';
+export * from './document-agent.js';
+export * from './github-agent.js';
+export * from './github-write-agent.js';
+export * from './orchestrator.js';
+export * from './flow-agent.js';
+export * from './api-test-agent.js';
+export * from './security-test-agent.js';
+export * from './integration-test-agent.js';
+export * from './llm-config.js';
+export * from './grouping-agent.js';
+export * from './artifact-intel-agent.js';
+export * from './requirements-agent.js';
+export * from './scenario-agent.js';
+export * from './label-assignment-agent.js';
+export * from './repo-scan-agent.js';
+export * from './coverage-map-agent.js';
+export * from './step-coverage.js';
+export * from './crawl-diff-agent.js';
+export * from './enhancement-agent.js';
+export * from './coverage-gap-agent.js';
+export { estimateCost, loadPricingOverrides } from './token-pricing.js';
+export { parseTestCases, parseTestCasesWithCache, scenarioContextKey, sanitizeParsedCase, inferColumnMapping, saveColumnMapping, loadColumnMapping, headerSignature, extractTabularHeaders, extractScenarios, buildSeleniumHints, annotateWithSeleniumHints, parseJsonWithRepair, isFunctionizeFormat, } from './test-import-agent.js';
+export type { ColumnMapping, InferMappingResult, ScenarioSummary } from './test-import-agent.js';

package/dist/index.js

@@ -0,0 +1,67 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFunctionizeFormat = exports.parseJsonWithRepair = exports.annotateWithSeleniumHints = exports.buildSeleniumHints = exports.extractScenarios = exports.extractTabularHeaders = exports.headerSignature = exports.loadColumnMapping = exports.saveColumnMapping = exports.inferColumnMapping = exports.sanitizeParsedCase = exports.scenarioContextKey = exports.parseTestCasesWithCache = exports.parseTestCases = exports.loadPricingOverrides = exports.estimateCost = void 0;
+__exportStar(require("./test-case-agent.js"), exports);
+__exportStar(require("./test-script-agent.js"), exports);
+__exportStar(require("./data-agent.js"), exports);
+__exportStar(require("./field-detector-agent.js"), exports);
+__exportStar(require("./script-agent.js"), exports);
+__exportStar(require("./nlp-agent.js"), exports);
+__exportStar(require("./healing-agent.js"), exports);
+__exportStar(require("./visual-agent.js"), exports);
+__exportStar(require("./skill-file-agent.js"), exports);
+__exportStar(require("./plan-agent.js"), exports);
+__exportStar(require("./llm.js"), exports);
+__exportStar(require("./llm-mock.js"), exports);
+__exportStar(require("./document-agent.js"), exports);
+__exportStar(require("./github-agent.js"), exports);
+__exportStar(require("./github-write-agent.js"), exports);
+__exportStar(require("./orchestrator.js"), exports);
+__exportStar(require("./flow-agent.js"), exports);
+__exportStar(require("./api-test-agent.js"), exports);
+__exportStar(require("./security-test-agent.js"), exports);
+__exportStar(require("./integration-test-agent.js"), exports);
+__exportStar(require("./llm-config.js"), exports);
+__exportStar(require("./grouping-agent.js"), exports);
+__exportStar(require("./artifact-intel-agent.js"), exports);
+__exportStar(require("./requirements-agent.js"), exports);
+__exportStar(require("./scenario-agent.js"), exports);
+__exportStar(require("./label-assignment-agent.js"), exports);
+__exportStar(require("./repo-scan-agent.js"), exports);
+__exportStar(require("./coverage-map-agent.js"), exports);
+__exportStar(require("./step-coverage.js"), exports);
+__exportStar(require("./crawl-diff-agent.js"), exports);
+__exportStar(require("./enhancement-agent.js"), exports);
+__exportStar(require("./coverage-gap-agent.js"), exports);
+var token_pricing_js_1 = require("./token-pricing.js");
+Object.defineProperty(exports, "estimateCost", { enumerable: true, get: function () { return token_pricing_js_1.estimateCost; } });
+Object.defineProperty(exports, "loadPricingOverrides", { enumerable: true, get: function () { return token_pricing_js_1.loadPricingOverrides; } });
+var test_import_agent_js_1 = require("./test-import-agent.js");
+Object.defineProperty(exports, "parseTestCases", { enumerable: true, get: function () { return test_import_agent_js_1.parseTestCases; } });
+Object.defineProperty(exports, "parseTestCasesWithCache", { enumerable: true, get: function () { return test_import_agent_js_1.parseTestCasesWithCache; } });
+Object.defineProperty(exports, "scenarioContextKey", { enumerable: true, get: function () { return test_import_agent_js_1.scenarioContextKey; } });
+Object.defineProperty(exports, "sanitizeParsedCase", { enumerable: true, get: function () { return test_import_agent_js_1.sanitizeParsedCase; } });
+Object.defineProperty(exports, "inferColumnMapping", { enumerable: true, get: function () { return test_import_agent_js_1.inferColumnMapping; } });
+Object.defineProperty(exports, "saveColumnMapping", { enumerable: true, get: function () { return test_import_agent_js_1.saveColumnMapping; } });
+Object.defineProperty(exports, "loadColumnMapping", { enumerable: true, get: function () { return test_import_agent_js_1.loadColumnMapping; } });
+Object.defineProperty(exports, "headerSignature", { enumerable: true, get: function () { return test_import_agent_js_1.headerSignature; } });
+Object.defineProperty(exports, "extractTabularHeaders", { enumerable: true, get: function () { return test_import_agent_js_1.extractTabularHeaders; } });
+Object.defineProperty(exports, "extractScenarios", { enumerable: true, get: function () { return test_import_agent_js_1.extractScenarios; } });
+Object.defineProperty(exports, "buildSeleniumHints", { enumerable: true, get: function () { return test_import_agent_js_1.buildSeleniumHints; } });
+Object.defineProperty(exports, "annotateWithSeleniumHints", { enumerable: true, get: function () { return test_import_agent_js_1.annotateWithSeleniumHints; } });
+Object.defineProperty(exports, "parseJsonWithRepair", { enumerable: true, get: function () { return test_import_agent_js_1.parseJsonWithRepair; } });
+Object.defineProperty(exports, "isFunctionizeFormat", { enumerable: true, get: function () { return test_import_agent_js_1.isFunctionizeFormat; } });

package/dist/integration-test-agent.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Integration Test Agent — UI/API/DB Full Stack Verification
+ *
+ * Generates tests that verify the full stack:
+ *   UI action → API call → backend state change → assertion
+ *
+ * Uses: API_CONTRACT, DATA_MODEL, INTERACTION_PATTERNS, TECH_STACK
+ * Test kinds: INTEGRATION, POSITIVE, NEGATIVE
+ *
+ * DB setup/teardown uses "TODO_DB_CONNECTION" placeholder that
+ * developers replace with their actual connection string.
+ */
+export interface IntegrationTestCase {
+    title: string;
+    kind: 'INTEGRATION' | 'POSITIVE' | 'NEGATIVE';
+    priority: 'CRITICAL' | 'HIGH' | 'MEDIUM';
+    integrationLayer: 'UI_API' | 'API_DB' | 'UI_API_DB' | 'SERVICE_SERVICE';
+    preconditions: string;
+    dbSetup: string;
+    steps: string[];
+    apiAssertions: string[];
+    dbAssertions: string[];
+    expectedResult: string;
+    dbTeardown: string;
+    groundedOn: string[];
+    tags: string[];
+}
+export declare function generateIntegrationTests(opts: {
+    tenantId: string;
+    projectId: string;
+    apiEndpoints?: Array<{
+        method: string;
+        urlPattern: string;
+    }>;
+}): Promise<{
+    status: string;
+    cases: never[];
+    saved: null;
+    suiteName?: undefined;
+} | {
+    status: string;
+    cases: IntegrationTestCase[];
+    saved: {
+        suite: {
+            tenantId: string;
+            id: string;
+            projectId: string;
+            name: string;
+            createdAt: Date;
+            genModel: string | null;
+            category: import(".prisma/client").$Enums.SuiteCategory | null;
+            parentId: string | null;
+            ownerUserId: string | null;
+            genTotalTokens: number | null;
+            genTotalCostUsd: number | null;
+            genAt: Date | null;
+            genScreenCount: number | null;
+            coverageReport: import("@prisma/client/runtime/library").JsonValue | null;
+        };
+        testCases: {
+            tenantId: string;
+            screenId: string | null;
+            id: string;
+            projectId: string;
+            source: string;
+            status: string;
+            createdAt: Date;
+            updatedAt: Date;
+            steps: import("@prisma/client/runtime/library").JsonValue;
+            kind: string;
+            tags: import("@prisma/client/runtime/library").JsonValue;
+            approvedBy: string | null;
+            suiteId: string;
+            ref: string | null;
+            title: string;
+            priority: string;
+            preconditions: string | null;
+            expectedResult: string | null;
+            gherkin: string | null;
+            approvedAt: Date | null;
+            groundedOn: import("@prisma/client/runtime/library").JsonValue;
+            caseRefs: import("@prisma/client/runtime/library").JsonValue;
+            viewports: import("@prisma/client/runtime/library").JsonValue;
+            viewportConstraint: string;
+            techniqueOfRecord: string | null;
+            traceTo: string | null;
+            traceToExtra: import("@prisma/client/runtime/library").JsonValue;
+            testDataInline: import("@prisma/client/runtime/library").JsonValue | null;
+            dataNote: string | null;
+            scriptNote: string | null;
+            structuredSteps: import("@prisma/client/runtime/library").JsonValue | null;
+            artifactId: string | null;
+            scenarioId: string | null;
+            suspect: boolean;
+            suspectReason: string | null;
+            flakyScore: number;
+            consecutiveFlakes: number;
+            lastFlakyAt: Date | null;
+            quarantined: boolean;
+            quarantinedAt: Date | null;
+            quarantineReason: string | null;
+            genPromptTokens: number | null;
+            genCompletionTokens: number | null;
+            genCostUsd: number | null;
+            genModel: string | null;
+            dataSetId: string | null;
+            repoTargetPath: string | null;
+            stepsKey: string | null;
+            gherkinKey: string | null;
+            contentHash: string | null;
+            groundingHash: string | null;
+            locatorsJson: import("@prisma/client/runtime/library").JsonValue | null;
+            locatorsExtractedAt: Date | null;
+            captureStepScreenshots: import("@prisma/client/runtime/library").JsonValue | null;
+        }[];
+    };
+    suiteName: string;
+}>;

package/dist/integration-test-agent.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Integration Test Agent — UI/API/DB Full Stack Verification
+ *
+ * Generates tests that verify the full stack:
+ *   UI action → API call → backend state change → assertion
+ *
+ * Uses: API_CONTRACT, DATA_MODEL, INTERACTION_PATTERNS, TECH_STACK
+ * Test kinds: INTEGRATION, POSITIVE, NEGATIVE
+ *
+ * DB setup/teardown uses "TODO_DB_CONNECTION" placeholder that
+ * developers replace with their actual connection string.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIntegrationTests = generateIntegrationTests;
+const app_brain_1 = require("@taodigital/app-brain");
+const core_1 = require("@taodigital/core");
+const llm_js_1 = require("./llm.js");
+const llm_config_js_1 = require("./llm-config.js");
+async function generateIntegrationTests(opts) {
+    const llmCfg = await (0, llm_config_js_1.getTaskAgentLLMConfig)(opts.tenantId, 'testGeneration');
+    const project = await app_brain_1.AppBrain.getProjectMap(opts.tenantId, opts.projectId);
+    if (!project)
+        return { status: 'NO_PROJECT', cases: [], saved: null };
+    const screens = project.screens ?? [];
+    // Focus on screens with forms / interactive elements
+    const formScreens = screens
+        .filter((s) => (s.elements ?? []).some((e) => ['submit', 'button', 'form', 'input', 'checkbox', 'textarea'].some((r) => (e.role ?? '').toLowerCase().includes(r))))
+        .slice(0, 15)
+        .map((s) => {
+        const els = (s.elements ?? [])
+            .filter((e) => e.isInteractive)
+            .slice(0, 6)
+            .map((e) => `    - ${e.role}: "${e.meaning}"${e.expectedData ? ` (${e.expectedData})` : ''}`)
+            .join('\n');
+        return `Screen: ${s.name}${s.url ? ` (${s.url})` : ''}\n  Interactive elements:\n${els || '    (none)'}`;
+    })
+        .join('\n\n');
+    const skillFiles = await app_brain_1.AppBrain.listSkillFiles(opts.tenantId, opts.projectId, ['API_CONTRACT', 'DATA_MODEL', 'INTERACTION_PATTERNS', 'TECH_STACK']);
+    const skillCtx = skillFiles.map((sf) => `### ${sf.kind}\n${sf.content}`).join('\n\n');
+    const endpointSummary = (opts.apiEndpoints ?? []).slice(0, 30)
+        .map((e) => `  ${e.method} ${e.urlPattern}`)
+        .join('\n');
+    const SYSTEM_DEFAULT = `You are an expert integration QA engineer generating full-stack test cases.
+Integration tests verify UI actions correctly modify backend state — not just that the UI shows success.
+
+TEST STRUCTURE per case:
+1. dbSetup: SQL/ORM to seed required data (use TODO_DB_CONNECTION as the connection variable)
+2. steps: Playwright UI actions on actual screen elements
+3. apiAssertions: Exact API response checks (status + fields)
+4. dbAssertions: Exact DB state checks after the operation
+5. dbTeardown: Cleanup SQL/ORM
+
+INTEGRATION LAYERS:
+- UI_API: UI action triggers correct API call with correct payload
+- API_DB: API call correctly persists/reads from database
+- UI_API_DB: Full stack — UI triggers API which updates DB, then UI reflects new state
+- SERVICE_SERVICE: Backend service correctly calls another service
+
+GROUNDING RULES:
+- Only reference screen elements from the list below
+- Only reference API endpoints from the list below
+- DB operations use the DATA_MODEL schema
+- DB steps use "TODO_DB_CONNECTION" placeholder
+
+OUTPUT FORMAT — valid JSON array only, no markdown:
+[
+  {
+    "title": "string",
+    "kind": "INTEGRATION|POSITIVE|NEGATIVE",
+    "priority": "CRITICAL|HIGH|MEDIUM",
+    "integrationLayer": "UI_API|API_DB|UI_API_DB|SERVICE_SERVICE",
+    "preconditions": "string",
+    "dbSetup": "string (SQL/ORM with TODO_DB_CONNECTION)",
+    "steps": ["UI step1", "UI step2"],
+    "apiAssertions": ["Assert status 201", "Assert response.id is not null"],
+    "dbAssertions": ["Assert DB: SELECT COUNT(*) FROM table WHERE... = 1"],
+    "expectedResult": "string",
+    "dbTeardown": "string (cleanup)",
+    "groundedOn": ["ScreenName.ElementMeaning or endpoint:METHOD /path"],
+    "tags": ["integration"]
+  }
+]`;
+    const user = `Generate integration test cases verifying full-stack behavior.
+
+SCREENS WITH INTERACTIVE FORMS:
+${formScreens || '  (No form screens found — run a crawl first)'}
+
+API ENDPOINTS:
+${endpointSummary || '  (No endpoints captured)'}
+
+SKILL FILE CONTEXT:
+${skillCtx.slice(0, 5000)}
+
+Generate tests for:
+1. FORM SUBMIT → API → DB (UI_API_DB): Fill form → API persists → DB has new record
+2. LOGIN → SESSION → PROTECTED RESOURCE (UI_API): Auth creates valid session token
+3. CREATE → READ (API_DB): POST creates resource → GET returns it with correct fields
+4. UPDATE → VERIFY (UI_API_DB): Edit form → API PATCH → DB shows new value → UI reflects
+5. DELETE → 404 (UI_API_DB): UI delete → API DELETE → resource no longer accessible
+6. CONCURRENT MODIFICATION (NEGATIVE): Two updates to same record → conflict handled
+7. INVALID STATE TRANSITION (NEGATIVE): UI tries illegal state change → API rejects, DB unchanged
+
+Rules:
+- dbSetup/dbTeardown use "TODO_DB_CONNECTION" as the connection variable
+- apiAssertions must be exact: status code + specific field name checks
+- dbAssertions must be exact: specific column/table queries after the operation
+- Reference ACTUAL element names and endpoint paths from context above`;
+    const seed = (0, llm_js_1.deterministicSeed)(`${opts.tenantId}:${opts.projectId}:integration:${endpointSummary.slice(0, 300)}`);
+    const system = await (0, core_1.getAgentPrompt)('integration-test-generation', undefined, opts.tenantId) ?? SYSTEM_DEFAULT;
+    let parsed = [];
+    const t0 = Date.now();
+    try {
+        const { text: raw, usage } = await (0, llm_js_1.askTracked)(system, user, llmCfg, undefined, undefined, { temperature: 0, seed });
+        const latencyMs = Date.now() - t0;
+        (0, app_brain_1.recordLLMCall)({
+            tenantId: opts.tenantId, projectId: opts.projectId,
+            agentType: 'integration_test', label: 'integration_test_generation', usage, latencyMs,
+        }).catch(console.error);
+        const jsonMatch = raw.match(/\[[\s\S]*\]/);
+        if (jsonMatch) {
+            const items = JSON.parse(jsonMatch[0]);
+            parsed = items
+                .filter((tc) => tc.title && Array.isArray(tc.steps) && tc.steps.length >= 1)
+                .map((tc) => ({
+                title: String(tc.title).slice(0, 200),
+                kind: (['INTEGRATION', 'POSITIVE', 'NEGATIVE'].includes(tc.kind) ? tc.kind : 'INTEGRATION'),
+                priority: (['CRITICAL', 'HIGH', 'MEDIUM'].includes(tc.priority) ? tc.priority : 'HIGH'),
+                integrationLayer: (['UI_API', 'API_DB', 'UI_API_DB', 'SERVICE_SERVICE'].includes(tc.integrationLayer) ? tc.integrationLayer : 'UI_API_DB'),
+                preconditions: String(tc.preconditions || '').slice(0, 300),
+                dbSetup: String(tc.dbSetup || '').slice(0, 600),
+                steps: tc.steps.map((s) => String(s).slice(0, 400)),
+                apiAssertions: Array.isArray(tc.apiAssertions) ? tc.apiAssertions.map((a) => String(a).slice(0, 300)) : [],
+                dbAssertions: Array.isArray(tc.dbAssertions) ? tc.dbAssertions.map((a) => String(a).slice(0, 300)) : [],
+                expectedResult: String(tc.expectedResult || '').slice(0, 500),
+                dbTeardown: String(tc.dbTeardown || '').slice(0, 400),
+                groundedOn: Array.isArray(tc.groundedOn) ? tc.groundedOn.map(String) : [],
+                tags: ['integration', tc.integrationLayer || 'UI_API_DB', ...(Array.isArray(tc.tags) ? tc.tags.map(String) : [])],
+            }));
+        }
+    }
+    catch (e) {
+        console.error('[integration-test-agent] parse error:', e?.message);
+    }
+    if (parsed.length === 0)
+        return { status: 'LLM_EMPTY', cases: [], saved: null };
+    const suiteName = 'Integration Tests: Full Stack';
+    const saved = await app_brain_1.AppBrain.saveGeneratedTestCases(opts.tenantId, opts.projectId, suiteName, parsed.map((tc) => ({
+        title: tc.title,
+        kind: tc.kind,
+        priority: tc.priority,
+        preconditions: `${tc.preconditions}\n\nDB Setup: ${tc.dbSetup}`,
+        steps: [
+            ...tc.steps,
+            ...tc.apiAssertions.map((a) => `Assert API: ${a}`),
+            ...tc.dbAssertions.map((a) => `Assert DB: ${a}`),
+        ],
+        expectedResult: `${tc.expectedResult}\n\nDB Teardown: ${tc.dbTeardown}`,
+        groundedOn: tc.groundedOn,
+        tags: tc.tags,
+        source: 'AI_GENERATED',
+    })));
+    console.log(`[integration-test-agent] ${parsed.length} integration test cases saved`);
+    return { status: 'GENERATED', cases: parsed, saved, suiteName };
+}

package/dist/label-assignment-agent.d.ts

@@ -0,0 +1,15 @@
+export interface LabelInput {
+    id: string;
+    title: string;
+    stepsText: string;
+    expectedResult?: string;
+}
+export interface LabelResult {
+    id: string;
+    priority: 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW';
+    inferredKind: string;
+    tags: string[];
+    confidence: number;
+    needsReview: boolean;
+}
+export declare function labelTestCasesBatch(cases: LabelInput[], tenantId: string): Promise<LabelResult[]>;