@allurereport/plugin-agent 3.10.0 → 3.11.0

package/dist/query.d.ts

@@ -0,0 +1,193 @@
+import type { TestStatus } from "@allurereport/core-api";
+import type { AgentFindingCategory, AgentFindingSeverity, AgentOutputBundle, AgentTestManifestLine } from "./harness.js";
+import type { AgentLabelFilter } from "./selection.js";
+export declare const AGENT_QUERY_SCHEMA = "allure-agent-query/v1";
+export declare const AGENT_QUERY_VIEWS: readonly ["summary", "tests", "findings", "test"];
+export declare const AGENT_TEST_STATUSES: TestStatus[];
+export declare const AGENT_FINDING_SEVERITIES: AgentFindingSeverity[];
+export declare const AGENT_FINDING_CATEGORIES: AgentFindingCategory[];
+export type AgentQueryView = (typeof AGENT_QUERY_VIEWS)[number];
+export type AgentQueryFilters = {
+    environments?: string[];
+    labelFilters: AgentLabelFilter[];
+    statuses?: TestStatus[];
+    severities?: AgentFindingSeverity[];
+    categories?: AgentFindingCategory[];
+    checks?: string[];
+    test?: string;
+    limit?: number;
+    includeMarkdown?: boolean;
+};
+export declare const normalizeAgentQueryView: (value?: string) => AgentQueryView;
+export declare const normalizeRepeatedEnumValues: <T extends string>(values: string[] | undefined, allowed: readonly T[], optionName: string) => T[] | undefined;
+export declare const normalizeRepeatedStringValues: (values: string[] | undefined) => string[] | undefined;
+export declare const normalizeAgentQueryLimit: (value?: string) => number | undefined;
+export declare const buildAgentQueryPayload: (output: AgentOutputBundle, view: AgentQueryView, filters: AgentQueryFilters) => Promise<{
+    expected?: import("./harness.js").AgentExpectations | undefined;
+    schema: string;
+    view: string;
+    output_dir: string;
+    index_md: string | null;
+    run: {
+        schema_version: string;
+        generated_at: string;
+        phase: "running" | "done" | null;
+        command: string | null;
+        exit_code: {
+            original: number;
+            actual: number | null;
+        } | null;
+        expectations_present: boolean;
+        expectation_result: {
+            schema_version: "allure-agent-expectation-result/v1";
+            status: import("./harness.js").AgentExpectationResultStatus;
+            impact: import("./harness.js").AgentExpectationResultImpact;
+            source: {
+                kind: "inline" | "file" | "none";
+                path: string | null;
+            };
+            recognized_control_count: number;
+            unsupported_controls: string[];
+            degraded_controls: string[];
+            summary: {
+                expected_tests: number;
+                observed_tests: number;
+                missing_expected: number;
+                forbidden_observed: number;
+                unexpected_observed: number;
+                evidence_mismatches: number;
+            };
+            finding_ids: string[];
+        };
+        agent_context: {
+            agent_name: string | null;
+            loop_id: string | null;
+            task_id: string | null;
+            conversation_id: string | null;
+        };
+    };
+    summary: {
+        stats: import("@allurereport/core-api").Statistic;
+        modeled_stats?: {
+            total: number;
+            failed: number;
+            broken: number;
+            skipped: number;
+            unknown: number;
+            passed: number;
+        };
+        unmodeled_from_stats?: {
+            total: number;
+            failed: number;
+            broken: number;
+            skipped: number;
+            unknown: number;
+            passed: number;
+        };
+        compact?: {
+            visible_results: number;
+            logical_tests: number;
+            unmodeled_visible_results: number;
+            runner_failures_outside_logical_tests: number;
+            completeness: "complete" | "partial";
+            findings?: number;
+        };
+        duration_ms: {
+            total: number;
+            average: number;
+            max: number;
+        };
+        environments: Array<{
+            environmentId: string;
+            total: number;
+            failed: number;
+            broken: number;
+            skipped: number;
+            unknown: number;
+            passed: number;
+        }>;
+    };
+    modeling: {
+        completeness: "complete" | "partial";
+        reasons: string[];
+        modeledStats: {
+            total: number;
+            failed: number;
+            broken: number;
+            skipped: number;
+            unknown: number;
+            passed: number;
+        };
+        unmodeledFromStats: {
+            total: number;
+            failed: number;
+            broken: number;
+            skipped: number;
+            unknown: number;
+            passed: number;
+        };
+        runnerFailures: {
+            total: number;
+            globalErrors: number;
+            stderrActionable: number;
+            samples: Array<{
+                source: "stderr" | "global_error";
+                kind: "import" | "suite-load" | "setup" | "global-error";
+                message: string;
+                count: number;
+            }>;
+        };
+        stderr: {
+            actionableCount: number;
+            actionableSamples: string[];
+            noisyWarningCount: number;
+            noisyWarningSamples: string[];
+        };
+        compact: {
+            visible_results: number;
+            logical_tests: number;
+            unmodeled_visible_results: number;
+            runner_failures_outside_logical_tests: number;
+            completeness: "complete" | "partial";
+        };
+    } | null;
+    check_summary: {
+        total: number;
+        countsBySeverity: Record<AgentFindingSeverity, number>;
+        countsByCategory: Record<AgentFindingCategory, number>;
+    };
+    paths: {
+        index_md: string | null;
+        agents_md: string | null;
+        tests_manifest: string | null;
+        findings_manifest: string | null;
+        test_events_manifest: string | null;
+        expected_manifest: string | null;
+        process_logs: {
+            stdout: string | null;
+            stderr: string | null;
+        };
+    };
+} | {
+    schema: string;
+    view: string;
+    output_dir: string;
+    total_matches: number;
+    returned: number;
+    tests: AgentTestManifestLine[];
+} | {
+    schema: string;
+    view: string;
+    output_dir: string;
+    total_matches: number;
+    returned: number;
+    findings: import("./harness.js").AgentFindingManifestLine[];
+} | {
+    markdown?: string | undefined;
+    schema: string;
+    view: string;
+    output_dir: string;
+    markdown_path: string | null;
+    test: AgentTestManifestLine;
+    findings: import("./harness.js").AgentFindingManifestLine[];
+}>;

package/dist/query.js

@@ -0,0 +1,175 @@
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { AgentUsageError } from "./errors.js";
+export const AGENT_QUERY_SCHEMA = "allure-agent-query/v1";
+export const AGENT_QUERY_VIEWS = ["summary", "tests", "findings", "test"];
+export const AGENT_TEST_STATUSES = ["failed", "broken", "unknown", "skipped", "passed"];
+export const AGENT_FINDING_SEVERITIES = ["high", "warning", "info"];
+export const AGENT_FINDING_CATEGORIES = [
+    "bootstrap",
+    "scope",
+    "metadata",
+    "evidence",
+    "smells",
+];
+export const normalizeAgentQueryView = (value) => {
+    if (!value) {
+        return "summary";
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!AGENT_QUERY_VIEWS.includes(normalized)) {
+        throw new AgentUsageError(`Invalid query view ${JSON.stringify(value)}. Expected one of: ${AGENT_QUERY_VIEWS.join(", ")}`);
+    }
+    return normalized;
+};
+const normalizeOptionalStringValues = (values) => values?.map((value) => value.trim()).filter(Boolean) ?? [];
+export const normalizeRepeatedEnumValues = (values, allowed, optionName) => {
+    const normalized = normalizeOptionalStringValues(values).map((value) => value.toLowerCase());
+    if (!normalized.length) {
+        return undefined;
+    }
+    const invalid = normalized.find((value) => !allowed.includes(value));
+    if (invalid) {
+        throw new AgentUsageError(`Invalid ${optionName} value ${JSON.stringify(invalid)}. Expected one of: ${allowed.join(", ")}`);
+    }
+    return normalized;
+};
+export const normalizeRepeatedStringValues = (values) => {
+    const normalized = normalizeOptionalStringValues(values);
+    return normalized.length ? normalized : undefined;
+};
+export const normalizeAgentQueryLimit = (value) => {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!/^\d+$/.test(value)) {
+        throw new AgentUsageError("--limit must be a non-negative integer");
+    }
+    const parsed = Number(value);
+    if (!Number.isSafeInteger(parsed)) {
+        throw new AgentUsageError("--limit must be a non-negative integer");
+    }
+    return parsed;
+};
+const matchesLabelFilters = (labels, filters) => filters.every((filter) => labels.some((label) => label.name === filter.name && label.value === filter.value));
+const matchesAgentTestIdentifier = (test, identifier) => test.full_name === identifier ||
+    test.test_result_id === identifier ||
+    test.history_id === identifier ||
+    test.markdown_path === identifier;
+const agentFindingSubjectRef = (finding) => {
+    if (finding.subject_ref) {
+        return finding.subject_ref;
+    }
+    if (typeof finding.subject === "string") {
+        return finding.subject;
+    }
+    return finding.subject.path ?? finding.subject.id ?? finding.subject.type;
+};
+const agentFindingCheckName = (finding) => finding.check_id ?? finding.check_name;
+const filterAgentQueryTests = (tests, filters) => tests
+    .filter((test) => (filters.statuses?.length ? filters.statuses.includes(test.status) : true))
+    .filter((test) => (filters.environments?.length ? filters.environments.includes(test.environment_id) : true))
+    .filter((test) => (filters.labelFilters.length ? matchesLabelFilters(test.labels, filters.labelFilters) : true))
+    .filter((test) => (filters.test ? matchesAgentTestIdentifier(test, filters.test) : true));
+const hasAgentQueryTestFilters = (filters) => Boolean(filters.statuses?.length || filters.environments?.length || filters.labelFilters.length || filters.test);
+const filterAgentQueryFindings = (output, filters) => {
+    const matchedSubjects = hasAgentQueryTestFilters(filters)
+        ? new Set(filterAgentQueryTests(output.tests, filters).map((test) => test.markdown_path))
+        : undefined;
+    return output.findings
+        .filter((finding) => (matchedSubjects ? matchedSubjects.has(agentFindingSubjectRef(finding)) : true))
+        .filter((finding) => (filters.severities?.length ? filters.severities.includes(finding.severity) : true))
+        .filter((finding) => (filters.categories?.length ? filters.categories.includes(finding.category) : true))
+        .filter((finding) => (filters.checks?.length ? filters.checks.includes(agentFindingCheckName(finding)) : true));
+};
+const applyAgentQueryLimit = (items, limit) => limit === undefined ? items : items.slice(0, limit);
+const resolveAgentOutputPath = (output, relativePath) => relativePath ? join(output.outputDir, relativePath) : null;
+const buildAgentQuerySummaryPayload = (output) => ({
+    schema: AGENT_QUERY_SCHEMA,
+    view: "summary",
+    output_dir: output.outputDir,
+    index_md: resolveAgentOutputPath(output, output.run.paths.index_md),
+    run: {
+        schema_version: output.run.schema_version,
+        generated_at: output.run.generated_at,
+        phase: output.run.phase ?? null,
+        command: output.run.command,
+        exit_code: output.run.exit_code,
+        expectations_present: output.run.expectations_present,
+        expectation_result: output.run.expectation_result,
+        agent_context: output.run.agent_context,
+    },
+    summary: output.run.summary,
+    modeling: output.run.modeling ?? null,
+    check_summary: output.run.check_summary,
+    paths: {
+        index_md: resolveAgentOutputPath(output, output.run.paths.index_md),
+        agents_md: resolveAgentOutputPath(output, output.run.paths.agents_md),
+        tests_manifest: resolveAgentOutputPath(output, output.run.paths.tests_manifest),
+        findings_manifest: resolveAgentOutputPath(output, output.run.paths.findings_manifest),
+        test_events_manifest: resolveAgentOutputPath(output, output.run.paths.test_events_manifest),
+        expected_manifest: resolveAgentOutputPath(output, output.run.paths.expected_manifest),
+        process_logs: {
+            stdout: resolveAgentOutputPath(output, output.run.paths.process_logs.stdout),
+            stderr: resolveAgentOutputPath(output, output.run.paths.process_logs.stderr),
+        },
+    },
+    ...(output.expected ? { expected: output.expected } : {}),
+});
+const buildAgentQueryTestsPayload = (output, filters) => {
+    const matched = filterAgentQueryTests(output.tests, filters);
+    const returned = applyAgentQueryLimit(matched, filters.limit);
+    return {
+        schema: AGENT_QUERY_SCHEMA,
+        view: "tests",
+        output_dir: output.outputDir,
+        total_matches: matched.length,
+        returned: returned.length,
+        tests: returned,
+    };
+};
+const buildAgentQueryFindingsPayload = (output, filters) => {
+    const matched = filterAgentQueryFindings(output, filters);
+    const returned = applyAgentQueryLimit(matched, filters.limit);
+    return {
+        schema: AGENT_QUERY_SCHEMA,
+        view: "findings",
+        output_dir: output.outputDir,
+        total_matches: matched.length,
+        returned: returned.length,
+        findings: returned,
+    };
+};
+const buildAgentQueryTestPayload = async (output, filters) => {
+    const matched = filterAgentQueryTests(output.tests, filters);
+    if (!matched.length) {
+        throw new AgentUsageError(`No tests matched query in ${output.outputDir}`);
+    }
+    if (matched.length > 1) {
+        throw new AgentUsageError(`Query matched ${matched.length} tests in ${output.outputDir}. Use --test <full-name-or-id>.`);
+    }
+    const test = matched[0];
+    const markdownPath = resolveAgentOutputPath(output, test.markdown_path);
+    const findings = output.findings.filter((finding) => agentFindingSubjectRef(finding) === test.markdown_path);
+    return {
+        schema: AGENT_QUERY_SCHEMA,
+        view: "test",
+        output_dir: output.outputDir,
+        markdown_path: markdownPath,
+        test,
+        findings,
+        ...(filters.includeMarkdown && markdownPath ? { markdown: await readFile(markdownPath, "utf-8") } : {}),
+    };
+};
+export const buildAgentQueryPayload = async (output, view, filters) => {
+    switch (view) {
+        case "summary":
+            return buildAgentQuerySummaryPayload(output);
+        case "tests":
+            return buildAgentQueryTestsPayload(output, filters);
+        case "findings":
+            return buildAgentQueryFindingsPayload(output, filters);
+        case "test":
+            return buildAgentQueryTestPayload(output, filters);
+    }
+};

package/dist/selection.d.ts

@@ -0,0 +1,42 @@
+import type { TestPlan } from "@allurereport/core-api";
+import { type AgentTestManifestLine } from "./harness.js";
+export type AgentRerunPreset = "review" | "failed" | "unsuccessful" | "all";
+export type AgentLabelFilter = {
+    name: string;
+    value: string;
+};
+export type AgentSelectionResult = {
+    outputDir: string;
+    preset: AgentRerunPreset;
+    selectedTests: AgentTestManifestLine[];
+    testPlan: TestPlan;
+};
+export type AgentTestPlanContext = {
+    outputDir: string;
+    preset: AgentRerunPreset;
+    selectedCount: number;
+    testPlanPath: string;
+    cleanup: () => Promise<void>;
+};
+export declare const AGENT_RERUN_PRESETS: AgentRerunPreset[];
+export declare const normalizeAgentRerunPreset: (value?: string) => AgentRerunPreset;
+export declare const parseAgentLabelFilters: (values?: string[]) => AgentLabelFilter[];
+export declare const resolveAgentSelectionOutputDir: (params: {
+    cwd: string;
+    from?: string;
+    latest?: boolean;
+}) => Promise<string>;
+export declare const selectAgentTestPlan: (params: {
+    outputDir: string;
+    preset?: AgentRerunPreset;
+    environments?: string[];
+    labelFilters?: AgentLabelFilter[];
+}) => Promise<AgentSelectionResult>;
+export declare const createAgentTestPlanContext: (params: {
+    cwd: string;
+    from?: string;
+    latest?: boolean;
+    preset?: AgentRerunPreset;
+    environments?: string[];
+    labelFilters?: AgentLabelFilter[];
+}) => Promise<AgentTestPlanContext | undefined>;

package/dist/selection.js

@@ -0,0 +1,141 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { AgentUsageError } from "./errors.js";
+import { loadAgentOutput, planAgentEnrichmentReview, } from "./harness.js";
+import { readLatestAgentState } from "./state.js";
+export const AGENT_RERUN_PRESETS = ["review", "failed", "unsuccessful", "all"];
+const ALLURE_ID_LABEL = "ALLURE_ID";
+const isAgentRerunPreset = (value) => AGENT_RERUN_PRESETS.includes(value);
+const readAllureId = (labels) => labels.find((label) => label.name === ALLURE_ID_LABEL)?.value;
+const matchesLabelFilters = (labels, filters) => filters.every((filter) => labels.some((label) => label.name === filter.name && label.value === filter.value));
+const buildTestPlan = (tests) => {
+    const seenSelectors = new Set();
+    const seenIds = new Set();
+    const selected = [];
+    for (const test of tests) {
+        const selector = test.full_name || undefined;
+        const id = readAllureId(test.labels);
+        if (selector && !seenSelectors.has(selector)) {
+            seenSelectors.add(selector);
+            if (id) {
+                seenIds.add(id);
+            }
+            selected.push({
+                selector,
+                ...(id ? { id } : {}),
+            });
+            continue;
+        }
+        if (id && !seenIds.has(id)) {
+            seenIds.add(id);
+            selected.push({ id });
+        }
+    }
+    return {
+        version: "1.0",
+        tests: selected,
+    };
+};
+const selectTestsByPreset = (output, preset) => {
+    switch (preset) {
+        case "review": {
+            const review = planAgentEnrichmentReview(output);
+            const targeted = new Set(review.rerun.targetedTests);
+            return output.tests.filter((test) => targeted.has(test.full_name));
+        }
+        case "failed":
+            return output.tests.filter((test) => test.status === "failed" || test.status === "broken");
+        case "unsuccessful":
+            return output.tests.filter((test) => test.status !== "passed");
+        case "all":
+            return output.tests;
+    }
+};
+export const normalizeAgentRerunPreset = (value) => {
+    if (!value) {
+        return "review";
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!isAgentRerunPreset(normalized)) {
+        throw new AgentUsageError(`Invalid rerun preset ${JSON.stringify(value)}. Expected one of: ${AGENT_RERUN_PRESETS.join(", ")}`);
+    }
+    return normalized;
+};
+export const parseAgentLabelFilters = (values) => (values ?? []).map((value) => {
+    const separatorIndex = value.indexOf("=");
+    if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+        throw new AgentUsageError(`Invalid label filter ${JSON.stringify(value)}. Expected the form name=value, for example feature=checkout`);
+    }
+    const name = value.slice(0, separatorIndex).trim();
+    const filterValue = value.slice(separatorIndex + 1).trim();
+    if (!name || !filterValue) {
+        throw new AgentUsageError(`Invalid label filter ${JSON.stringify(value)}. Expected the form name=value, for example feature=checkout`);
+    }
+    return {
+        name,
+        value: filterValue,
+    };
+});
+export const resolveAgentSelectionOutputDir = async (params) => {
+    const { cwd, from, latest } = params;
+    if (from && latest) {
+        throw new AgentUsageError("Use either --from or --latest, not both");
+    }
+    if (!from && !latest) {
+        throw new AgentUsageError("Expected either --from <path> or --latest");
+    }
+    if (from) {
+        return resolve(cwd, from);
+    }
+    const latestState = await readLatestAgentState(cwd);
+    if (!latestState) {
+        throw new AgentUsageError(`No latest agent output found for ${cwd}`);
+    }
+    return latestState.outputDir;
+};
+export const selectAgentTestPlan = async (params) => {
+    const preset = params.preset ?? "review";
+    const output = await loadAgentOutput(params.outputDir);
+    const selectedTests = selectTestsByPreset(output, preset)
+        .filter((test) => (params.environments?.length ? params.environments.includes(test.environment_id) : true))
+        .filter((test) => (params.labelFilters?.length ? matchesLabelFilters(test.labels, params.labelFilters) : true));
+    return {
+        outputDir: output.outputDir,
+        preset,
+        selectedTests,
+        testPlan: buildTestPlan(selectedTests),
+    };
+};
+export const createAgentTestPlanContext = async (params) => {
+    const { from, latest } = params;
+    if (!from && !latest) {
+        return undefined;
+    }
+    const outputDir = await resolveAgentSelectionOutputDir({
+        cwd: params.cwd,
+        from,
+        latest,
+    });
+    const selection = await selectAgentTestPlan({
+        outputDir,
+        preset: params.preset,
+        environments: params.environments,
+        labelFilters: params.labelFilters,
+    });
+    if (!selection.testPlan.tests.length) {
+        throw new AgentUsageError(`No tests matched rerun selection in ${selection.outputDir}. Adjust the preset or filters before rerunning.`);
+    }
+    const tempDir = await mkdtemp(join(tmpdir(), "allure-agent-select-"));
+    const testPlanPath = join(tempDir, "testplan.json");
+    await writeFile(testPlanPath, `${JSON.stringify(selection.testPlan, null, 2)}\n`, "utf-8");
+    return {
+        outputDir: selection.outputDir,
+        preset: selection.preset,
+        selectedCount: selection.testPlan.tests.length,
+        testPlanPath,
+        cleanup: async () => {
+            await rm(tempDir, { recursive: true, force: true });
+        },
+    };
+};

package/dist/state.d.ts

@@ -0,0 +1,15 @@
+export type AgentLatestState = {
+    schema: "allure-agent-latest/v1";
+    cwd: string;
+    outputDir: string;
+    expectationsPath?: string;
+    command: string;
+    startedAt: string;
+    finishedAt?: string;
+    status: "running" | "finished";
+    exitCode?: number | null;
+};
+export declare const ALLURE_AGENT_STATE_DIR_ENV = "ALLURE_AGENT_STATE_DIR";
+export declare const resolveAgentStateDir: (cwd: string) => string;
+export declare const writeLatestAgentState: (value: Omit<AgentLatestState, "schema">) => Promise<AgentLatestState>;
+export declare const readLatestAgentState: (cwd: string) => Promise<AgentLatestState | undefined>;

package/dist/state.js

@@ -0,0 +1,83 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+const AGENT_STATE_SCHEMA = "allure-agent-latest/v1";
+export const ALLURE_AGENT_STATE_DIR_ENV = "ALLURE_AGENT_STATE_DIR";
+const isFileNotFoundError = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+const projectHash = (cwd) => createHash("sha256").update(cwd).digest("hex").slice(0, 16);
+export const resolveAgentStateDir = (cwd) => {
+    const configuredDir = process.env[ALLURE_AGENT_STATE_DIR_ENV]?.trim();
+    if (configuredDir) {
+        return resolve(configuredDir);
+    }
+    return join(tmpdir(), `allure-agent-state-${projectHash(resolve(cwd))}`);
+};
+const projectStatePath = (cwd) => join(resolveAgentStateDir(cwd), "latest.json");
+const writeJsonAtomic = async (filePath, value) => {
+    await mkdir(dirname(filePath), { recursive: true });
+    const tempPath = `${filePath}.${process.pid}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf-8");
+    await rename(tempPath, filePath);
+};
+const isAgentLatestState = (value) => {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (candidate.schema === AGENT_STATE_SCHEMA &&
+        typeof candidate.cwd === "string" &&
+        typeof candidate.outputDir === "string" &&
+        typeof candidate.command === "string" &&
+        typeof candidate.startedAt === "string" &&
+        (candidate.expectationsPath === undefined || typeof candidate.expectationsPath === "string") &&
+        (candidate.finishedAt === undefined || typeof candidate.finishedAt === "string") &&
+        (candidate.status === "running" || candidate.status === "finished") &&
+        (candidate.exitCode === undefined || typeof candidate.exitCode === "number" || candidate.exitCode === null));
+};
+export const writeLatestAgentState = async (value) => {
+    const normalizedState = {
+        schema: AGENT_STATE_SCHEMA,
+        cwd: resolve(value.cwd),
+        outputDir: resolve(value.outputDir),
+        expectationsPath: value.expectationsPath ? resolve(value.expectationsPath) : undefined,
+        command: value.command,
+        startedAt: value.startedAt,
+        finishedAt: value.finishedAt,
+        status: value.status,
+        exitCode: value.exitCode,
+    };
+    await writeJsonAtomic(projectStatePath(normalizedState.cwd), normalizedState);
+    return normalizedState;
+};
+export const readLatestAgentState = async (cwd) => {
+    const normalizedCwd = resolve(cwd);
+    const statePath = projectStatePath(normalizedCwd);
+    let raw;
+    try {
+        raw = await readFile(statePath, "utf-8");
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+    const parsed = JSON.parse(raw);
+    if (!isAgentLatestState(parsed)) {
+        throw new Error(`Invalid latest agent state in ${statePath}`);
+    }
+    if (parsed.cwd !== normalizedCwd) {
+        return undefined;
+    }
+    try {
+        await stat(parsed.outputDir);
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return undefined;
+        }
+        throw error;
+    }
+    return parsed;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-agent",
-  "version": "3.10.0",
+  "version": "3.11.0",
   "description": "Allure Agent Plugin – AI-friendly markdown report generator",
   "keywords": [
     "agent",
@@ -27,16 +27,16 @@
     "build": "run clean && tsc --project ./tsconfig.json",
     "clean": "rimraf ./dist",
     "test": "rimraf ./out && vitest run",
-    "lint": "oxlint --import-plugin src test features stories",
-    "lint:fix": "oxlint --import-plugin --fix src test features stories"
+    "lint": "yarn run -T oxlint --import-plugin src test features stories",
+    "lint:fix": "yarn run -T oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.10.0",
-    "@allurereport/plugin-api": "3.10.0",
+    "@allurereport/core-api": "3.11.0",
+    "@allurereport/plugin-api": "3.11.0",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
-    "@allurereport/reader-api": "3.10.0",
+    "@allurereport/reader-api": "3.11.0",
     "@types/node": "^20",
     "@vitest/runner": "^2",
     "allure-js-commons": "^3",