@allurereport/plugin-agent 3.11.0 → 3.12.0

package/dist/plugin.js

@@ -783,6 +783,60 @@ const renderModelingSummary = (modeling) => {
         : "None");
     return lines.join("\n");
 };
+const cloneHumanReportStatus = (status) => ({
+    ...status,
+    reports: status.reports.map((report) => ({ ...report })),
+    ...(status.errors ? { errors: status.errors.map((error) => ({ ...error })) } : {}),
+});
+const resolveHumanReportStatus = async (provider) => {
+    if (!provider) {
+        return undefined;
+    }
+    const status = typeof provider === "function" ? await provider() : provider;
+    return status ? cloneHumanReportStatus(status) : undefined;
+};
+const renderHumanReportSection = (humanReport) => {
+    if (!humanReport) {
+        return undefined;
+    }
+    const lines = [
+        "## Human Report",
+        "",
+        `- Status: ${humanReport.status}`,
+        `- Mode: ${humanReport.mode}`,
+        `- Result Count: ${humanReport.result_count ?? "unknown"}`,
+        `- Threshold: ${humanReport.threshold}`,
+    ];
+    if (humanReport.path) {
+        lines.push(`- Path: [${escapeInlineMarkdown(humanReport.path)}](${normalizeMarkdownPath(humanReport.path)})`);
+    }
+    if (humanReport.reason) {
+        lines.push(`- Reason: ${escapeInlineMarkdown(humanReport.reason)}`);
+    }
+    if (humanReport.error) {
+        lines.push(`- Error: ${escapeInlineMarkdown(humanReport.error)}`);
+    }
+    if (humanReport.reports.length > 1) {
+        lines.push("");
+        lines.push("### Reports");
+        lines.push("");
+        lines.push(humanReport.reports
+            .map((report) => `- ${escapeInlineMarkdown(report.plugin_id)}: [${escapeInlineMarkdown(report.path)}](${normalizeMarkdownPath(report.path)})`)
+            .join("\n"));
+    }
+    if (humanReport.errors?.length) {
+        lines.push("");
+        lines.push("### Report Errors");
+        lines.push("");
+        lines.push(humanReport.errors
+            .map((error) => {
+            const prefix = error.plugin_id ? `${error.plugin_id}: ` : "";
+            return `- ${escapeInlineMarkdown(`${prefix}${error.message}`)}`;
+        })
+            .join("\n"));
+    }
+    return lines.join("\n");
+};
 const renderSelectorSummary = (title, selectors) => {
     if (!hasSelector(selectors) && selectors.testCount === undefined) {
         return `- ${title}: None`;
@@ -1282,7 +1336,7 @@ const renderTestFile = (params) => {
     return `${lines.join("\n").trimEnd()}\n`;
 };
 const renderIndex = (params) => {
-    const { context, command, generatedAt, phase, stats, durationSummary, environmentSummary, modelingSummary, expectations, tests, globalArtifacts, globalErrors, globalExitCode, qualityGateResults, findings, } = params;
+    const { context, command, generatedAt, phase, stats, durationSummary, environmentSummary, modelingSummary, expectations, tests, globalArtifacts, globalErrors, globalExitCode, qualityGateResults, findings, humanReport, } = params;
     const stdoutArtifact = globalArtifacts.find((artifact) => artifact.displayName === "stdout.txt");
     const stderrArtifact = globalArtifacts.find((artifact) => artifact.displayName === "stderr.txt");
     const remainingGlobalArtifacts = globalArtifacts.filter((artifact) => artifact.displayName !== "stdout.txt" && artifact.displayName !== "stderr.txt");
@@ -1343,6 +1397,11 @@ const renderIndex = (params) => {
         : "None");
     lines.push("");
     lines.push(renderModelingSummary(modelingSummary));
+    const humanReportSection = renderHumanReportSection(humanReport);
+    if (humanReportSection) {
+        lines.push("");
+        lines.push(humanReportSection);
+    }
     if (expectations) {
         lines.push("");
         lines.push("## Expected Scope");
@@ -2593,7 +2652,7 @@ const appendJsonlLine = async (path, item) => {
     await appendFile(path, `${JSON.stringify(item)}\n`, "utf-8");
 };
 const toRunManifest = (params) => {
-    const { context, command, agentContext, generatedAt, phase, expectations, snapshot } = params;
+    const { context, command, agentContext, generatedAt, phase, expectations, snapshot, humanReport } = params;
     const stdoutArtifact = snapshot.globalArtifacts.find((artifact) => artifact.displayName === "stdout.txt");
     const stderrArtifact = snapshot.globalArtifacts.find((artifact) => artifact.displayName === "stderr.txt");
     const originalExitCode = snapshot.globalExitCode?.original ?? null;
@@ -2637,11 +2696,13 @@ const toRunManifest = (params) => {
             findings_manifest: "manifest/findings.jsonl",
             test_events_manifest: "manifest/test-events.jsonl",
             expected_manifest: expectations?.relativePath ?? null,
+            human_report_manifest: humanReport ? "manifest/human-report.json" : null,
             process_logs: {
                 stdout: stdoutArtifact?.relativePath ?? null,
                 stderr: stderrArtifact?.relativePath ?? null,
             },
         },
+        human_report: humanReport ?? null,
         expectations_present: Boolean(expectations),
         expectations: expectations ? toExpectationModel(expectations) : null,
         expectation_result: expectationResult,
@@ -2659,6 +2720,7 @@ const writeSnapshotFiles = async (params) => {
     const { outputDir, context, command, generatedAt, expectations } = runtime;
     const nextTestPaths = new Set(snapshot.entries.map((entry) => entry.filePath));
     const nextAssetDirs = new Set(snapshot.entries.map((entry) => join(outputDir, entry.relativeAssetDir)));
+    const humanReport = await resolveHumanReportStatus(runtime.humanReport);
     for (const stalePath of runtime.currentTestPaths) {
         if (!nextTestPaths.has(stalePath)) {
             await rm(stalePath, { force: true });
@@ -2687,7 +2749,11 @@ const writeSnapshotFiles = async (params) => {
             phase,
             expectations,
             snapshot,
+            humanReport,
         })),
+        ...(humanReport
+            ? [writeJson(join(outputDir, "manifest", "human-report.json"), humanReport)]
+            : [rm(join(outputDir, "manifest", "human-report.json"), { force: true })]),
         writeJsonlSnapshot(join(outputDir, "manifest", "tests.jsonl"), snapshot.entries.map(toTestsManifestLine)),
         writeJsonlSnapshot(join(outputDir, "manifest", "findings.jsonl"), snapshot.combinedAllFindings.map(toFindingManifestLine)),
         writeTextAtomic(join(outputDir, "index.md"), renderIndex({
@@ -2706,6 +2772,7 @@ const writeSnapshotFiles = async (params) => {
             globalExitCode: snapshot.globalExitCode,
             qualityGateResults: snapshot.qualityGateResults,
             findings: snapshot.combinedAllFindings,
+            humanReport,
         })),
         writeTextAtomic(join(outputDir, "AGENTS.md"), renderAgentsGuide()),
     ]);
@@ -2958,6 +3025,7 @@ const createRuntimeState = async (params) => {
             taskId: options.taskId,
             conversationId: options.conversationId,
         },
+        humanReport: options.humanReport,
         createFinding,
         expectations: expectationLoadResult.expectations,
         expectationLoadFindings: expectationLoadResult.findings,

package/dist/query.d.ts

@@ -151,6 +151,7 @@ export declare const buildAgentQueryPayload: (output: AgentOutputBundle, view: A
             completeness: "complete" | "partial";
         };
     } | null;
+    human_report: import("./model.js").AgentHumanReportStatus | null;
     check_summary: {
         total: number;
         countsBySeverity: Record<AgentFindingSeverity, number>;
@@ -163,6 +164,7 @@ export declare const buildAgentQueryPayload: (output: AgentOutputBundle, view: A
         findings_manifest: string | null;
         test_events_manifest: string | null;
         expected_manifest: string | null;
+        human_report_manifest: string | null;
         process_logs: {
             stdout: string | null;
             stderr: string | null;

package/dist/query.js

@@ -101,6 +101,7 @@ const buildAgentQuerySummaryPayload = (output) => ({
     },
     summary: output.run.summary,
     modeling: output.run.modeling ?? null,
+    human_report: output.humanReport ?? output.run.human_report ?? null,
     check_summary: output.run.check_summary,
     paths: {
         index_md: resolveAgentOutputPath(output, output.run.paths.index_md),
@@ -109,6 +110,7 @@ const buildAgentQuerySummaryPayload = (output) => ({
         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),
+        human_report_manifest: resolveAgentOutputPath(output, output.run.paths.human_report_manifest),
         process_logs: {
             stdout: resolveAgentOutputPath(output, output.run.paths.process_logs.stdout),
             stderr: resolveAgentOutputPath(output, output.run.paths.process_logs.stderr),

package/dist/state.d.ts

@@ -1,15 +1,56 @@
-export type AgentLatestState = {
-    schema: "allure-agent-latest/v1";
+export { ALLURE_AGENT_STATE_DIR_ENV, resolveAgentStateDir } from "./utils.js";
+export type AgentRunState = {
+    schema: "allure-agent-run/v1";
+    runId: string;
     cwd: string;
     outputDir: string;
+    managedOutput: boolean;
     expectationsPath?: string;
     command: string;
-    startedAt: string;
-    finishedAt?: string;
+    startedAt: number;
+    finishedAt?: number;
     status: "running" | "finished";
     exitCode?: number | null;
+    pid?: number;
 };
-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 type AgentLatestState = AgentRunState;
+export type AgentStateCleanupResult = {
+    deleted: AgentRunState[];
+    failed: {
+        state: AgentRunState;
+        error: unknown;
+    }[];
+    retained: AgentRunState[];
+};
+export type AgentOrphanOutputCleanupResult = {
+    deleted: string[];
+    failed: {
+        outputDir: string;
+        error: unknown;
+    }[];
+    retained: string[];
+};
+export type AgentStaleStateCleanupResult = AgentStateCleanupResult & {
+    checked: number;
+    orphaned: AgentOrphanOutputCleanupResult;
+    skipped: {
+        cwd: string;
+        statePath: string;
+        reason: "locked";
+    }[];
+};
+export declare const writeAgentRunState: (value: Omit<AgentRunState, "schema">) => Promise<AgentRunState>;
+export declare const writeLatestAgentState: (value: Omit<AgentRunState, "schema">) => Promise<AgentRunState>;
+export declare const readAgentRunStates: (cwd: string) => Promise<AgentRunState[]>;
 export declare const readLatestAgentState: (cwd: string) => Promise<AgentLatestState | undefined>;
+export declare const cleanupAgentRunState: (params: {
+    cwd: string;
+    currentRunId?: string;
+    keepManagedRuns?: number;
+}) => Promise<AgentStateCleanupResult>;
+export declare const cleanupStaleAgentRunStates: (params: {
+    cwd: string;
+    currentRunId?: string;
+    staleOutputTtlMs?: number;
+    now?: number;
+}) => Promise<AgentStaleStateCleanupResult>;

package/dist/state.js

@@ -1,83 +1,277 @@
-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) => {
+import { appendFile, readFile, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { isFileNotFoundError, listAgentManagedTempOutputDirs, listAgentStatePaths, pathExists, projectStatePath, readPathMtimeMs, tryWithAgentStateLock, withAgentStateLock, writeJsonlAtomic, } from "./utils.js";
+export { ALLURE_AGENT_STATE_DIR_ENV, resolveAgentStateDir } from "./utils.js";
+const AGENT_RUN_STATE_SCHEMA = "allure-agent-run/v1";
+const AGENT_STALE_OUTPUT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+const isAgentRunState = (value) => {
     if (typeof value !== "object" || value === null) {
         return false;
     }
     const candidate = value;
-    return (candidate.schema === AGENT_STATE_SCHEMA &&
+    return (candidate.schema === AGENT_RUN_STATE_SCHEMA &&
+        typeof candidate.runId === "string" &&
         typeof candidate.cwd === "string" &&
         typeof candidate.outputDir === "string" &&
+        typeof candidate.managedOutput === "boolean" &&
         typeof candidate.command === "string" &&
-        typeof candidate.startedAt === "string" &&
+        typeof candidate.startedAt === "number" &&
+        Number.isSafeInteger(candidate.startedAt) &&
         (candidate.expectationsPath === undefined || typeof candidate.expectationsPath === "string") &&
-        (candidate.finishedAt === undefined || typeof candidate.finishedAt === "string") &&
+        (candidate.finishedAt === undefined ||
+            (typeof candidate.finishedAt === "number" && Number.isSafeInteger(candidate.finishedAt))) &&
         (candidate.status === "running" || candidate.status === "finished") &&
-        (candidate.exitCode === undefined || typeof candidate.exitCode === "number" || candidate.exitCode === null));
+        (candidate.exitCode === undefined || typeof candidate.exitCode === "number" || candidate.exitCode === null) &&
+        (candidate.pid === undefined || (typeof candidate.pid === "number" && Number.isSafeInteger(candidate.pid))));
 };
-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);
+const normalizeAgentRunState = (value) => ({
+    schema: AGENT_RUN_STATE_SCHEMA,
+    runId: value.runId,
+    cwd: resolve(value.cwd),
+    outputDir: resolve(value.outputDir),
+    managedOutput: value.managedOutput,
+    expectationsPath: value.expectationsPath ? resolve(value.expectationsPath) : undefined,
+    command: value.command,
+    startedAt: value.startedAt,
+    finishedAt: value.finishedAt,
+    status: value.status,
+    exitCode: value.exitCode,
+    pid: value.pid,
+});
+const readAgentRunStateFile = async (statePath, cwd) => {
+    const normalizedCwd = cwd === undefined ? undefined : resolve(cwd);
     let raw;
     try {
         raw = await readFile(statePath, "utf-8");
     }
     catch (error) {
         if (isFileNotFoundError(error)) {
-            return undefined;
+            return [];
         }
         throw error;
     }
-    const parsed = JSON.parse(raw);
-    if (!isAgentLatestState(parsed)) {
-        throw new Error(`Invalid latest agent state in ${statePath}`);
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .flatMap((line) => {
+        try {
+            const parsed = JSON.parse(line);
+            if (!isAgentRunState(parsed)) {
+                return [];
+            }
+            return normalizedCwd === undefined || parsed.cwd === normalizedCwd ? [parsed] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+};
+const readAgentRunStateLines = async (cwd) => {
+    const normalizedCwd = resolve(cwd);
+    return readAgentRunStateFile(projectStatePath(normalizedCwd), normalizedCwd);
+};
+const foldAgentRunStates = (states) => {
+    const order = [];
+    const latestByRunId = new Map();
+    for (const state of states) {
+        if (!latestByRunId.has(state.runId)) {
+            order.push(state.runId);
+        }
+        latestByRunId.set(state.runId, state);
     }
-    if (parsed.cwd !== normalizedCwd) {
-        return undefined;
+    return order
+        .map((runId) => latestByRunId.get(runId))
+        .filter((state) => state !== undefined)
+        .sort((a, b) => a.startedAt - b.startedAt || (a.finishedAt ?? a.startedAt) - (b.finishedAt ?? b.startedAt));
+};
+const getAgentRunStateAgeTimestamp = (state) => state.finishedAt ?? state.startedAt;
+const isManagedOutputStale = (state, now, staleOutputTtlMs) => state.managedOutput && now - getAgentRunStateAgeTimestamp(state) >= staleOutputTtlMs;
+const isAgentOutputDirectory = async (outputDir) => (await pathExists(join(outputDir, "manifest", "run.json"))) || (await pathExists(join(outputDir, "index.md")));
+const cleanupStaleAgentRunState = async (params) => {
+    const states = foldAgentRunStates(await readAgentRunStateLines(params.cwd));
+    const retained = [];
+    const deleted = [];
+    const failed = [];
+    for (const state of states) {
+        if (!(await pathExists(state.outputDir))) {
+            continue;
+        }
+        if (!isManagedOutputStale(state, params.now, params.staleOutputTtlMs)) {
+            retained.push(state);
+            continue;
+        }
+        try {
+            await rm(state.outputDir, { recursive: true, force: true });
+            deleted.push(state);
+        }
+        catch (error) {
+            retained.push(state);
+            failed.push({ state, error });
+        }
     }
-    try {
-        await stat(parsed.outputDir);
+    await writeJsonlAtomic(projectStatePath(params.cwd), retained);
+    return {
+        deleted,
+        failed,
+        retained,
+    };
+};
+const cleanupStaleOrphanAgentOutputs = async (params) => {
+    const outputDirs = await listAgentManagedTempOutputDirs();
+    const deleted = [];
+    const failed = [];
+    const retained = [];
+    for (const outputDir of outputDirs) {
+        const normalizedOutputDir = resolve(outputDir);
+        if (params.referencedOutputDirs.has(normalizedOutputDir)) {
+            retained.push(normalizedOutputDir);
+            continue;
+        }
+        let mtimeMs;
+        try {
+            mtimeMs = await readPathMtimeMs(normalizedOutputDir);
+        }
+        catch (error) {
+            if (!isFileNotFoundError(error)) {
+                failed.push({ outputDir: normalizedOutputDir, error });
+            }
+            continue;
+        }
+        if (params.now - mtimeMs < params.staleOutputTtlMs) {
+            retained.push(normalizedOutputDir);
+            continue;
+        }
+        if (!(await isAgentOutputDirectory(normalizedOutputDir))) {
+            retained.push(normalizedOutputDir);
+            continue;
+        }
+        try {
+            await rm(normalizedOutputDir, { recursive: true, force: true });
+            deleted.push(normalizedOutputDir);
+        }
+        catch (error) {
+            failed.push({ outputDir: normalizedOutputDir, error });
+        }
     }
-    catch (error) {
-        if (isFileNotFoundError(error)) {
-            return undefined;
+    return {
+        deleted,
+        failed,
+        retained,
+    };
+};
+export const writeAgentRunState = async (value) => {
+    const normalizedState = normalizeAgentRunState(value);
+    await withAgentStateLock(normalizedState.cwd, async () => {
+        await appendFile(projectStatePath(normalizedState.cwd), `${JSON.stringify(normalizedState)}\n`, "utf-8");
+    });
+    return normalizedState;
+};
+export const writeLatestAgentState = writeAgentRunState;
+export const readAgentRunStates = async (cwd) => foldAgentRunStates(await readAgentRunStateLines(cwd));
+export const readLatestAgentState = async (cwd) => {
+    const states = await readAgentRunStates(cwd);
+    for (let i = states.length - 1; i >= 0; i -= 1) {
+        const state = states[i];
+        if (await pathExists(state.outputDir)) {
+            return state;
         }
-        throw error;
     }
-    return parsed;
+    return undefined;
+};
+export const cleanupAgentRunState = async (params) => withAgentStateLock(params.cwd, async () => {
+    const keepManagedRuns = Math.max(0, params.keepManagedRuns ?? 1);
+    const states = foldAgentRunStates(await readAgentRunStateLines(params.cwd));
+    const existing = [];
+    for (const state of states) {
+        if (await pathExists(state.outputDir)) {
+            existing.push(state);
+        }
+    }
+    const retainedManagedRunIds = new Set(existing
+        .filter((state) => state.managedOutput && state.status === "finished")
+        .sort((a, b) => (b.finishedAt ?? b.startedAt) - (a.finishedAt ?? a.startedAt) || b.startedAt - a.startedAt)
+        .slice(0, keepManagedRuns)
+        .map((state) => state.runId));
+    if (params.currentRunId) {
+        retainedManagedRunIds.add(params.currentRunId);
+    }
+    const deleted = [];
+    const failed = [];
+    for (const state of existing) {
+        if (!state.managedOutput || state.status !== "finished" || retainedManagedRunIds.has(state.runId)) {
+            continue;
+        }
+        try {
+            await rm(state.outputDir, { recursive: true, force: true });
+            deleted.push(state);
+        }
+        catch (error) {
+            failed.push({ state, error });
+        }
+    }
+    const deletedRunIds = new Set(deleted.map((state) => state.runId));
+    const retained = existing.filter((state) => !deletedRunIds.has(state.runId));
+    await writeJsonlAtomic(projectStatePath(params.cwd), retained);
+    return {
+        deleted,
+        failed,
+        retained,
+    };
+});
+export const cleanupStaleAgentRunStates = async (params) => {
+    const currentCwd = resolve(params.cwd);
+    const currentStatePath = projectStatePath(currentCwd);
+    const statePaths = await listAgentStatePaths(currentCwd);
+    const staleOutputTtlMs = Math.max(0, params.staleOutputTtlMs ?? AGENT_STALE_OUTPUT_TTL_MS);
+    const now = params.now ?? Date.now();
+    const staleCwds = new Map();
+    const referencedOutputDirs = new Set();
+    for (const statePath of statePaths) {
+        const states = foldAgentRunStates(await readAgentRunStateFile(statePath));
+        for (const state of states) {
+            referencedOutputDirs.add(resolve(state.outputDir));
+            if (statePath === currentStatePath) {
+                continue;
+            }
+            if (state.cwd === currentCwd || state.runId === params.currentRunId) {
+                continue;
+            }
+            if (!(await pathExists(state.outputDir)) || isManagedOutputStale(state, now, staleOutputTtlMs)) {
+                staleCwds.set(state.cwd, statePath);
+                break;
+            }
+        }
+    }
+    const deleted = [];
+    const failed = [];
+    const retained = [];
+    const skipped = [];
+    for (const [cwd, statePath] of staleCwds) {
+        const lockResult = await tryWithAgentStateLock(cwd, () => cleanupStaleAgentRunState({
+            cwd,
+            now,
+            staleOutputTtlMs,
+        }));
+        if (!lockResult.acquired) {
+            skipped.push({ cwd, statePath, reason: "locked" });
+            continue;
+        }
+        deleted.push(...lockResult.result.deleted);
+        failed.push(...lockResult.result.failed);
+        retained.push(...lockResult.result.retained);
+    }
+    const orphaned = await cleanupStaleOrphanAgentOutputs({
+        referencedOutputDirs,
+        now,
+        staleOutputTtlMs,
+    });
+    return {
+        checked: statePaths.length,
+        deleted,
+        failed,
+        orphaned,
+        retained,
+        skipped,
+    };
 };

package/dist/utils.d.ts

@@ -0,0 +1,17 @@
+export declare const ALLURE_AGENT_STATE_DIR_ENV = "ALLURE_AGENT_STATE_DIR";
+export declare const AGENT_MANAGED_OUTPUT_DIR_PREFIX = "allure-agent-";
+export declare const isFileNotFoundError: (error: unknown) => error is NodeJS.ErrnoException;
+export declare const resolveAgentStateDir: (_cwd?: string) => string;
+export declare const projectStatePath: (cwd: string) => string;
+export declare const listAgentStatePaths: (cwd?: string) => Promise<string[]>;
+export declare const listAgentManagedTempOutputDirs: () => Promise<string[]>;
+export declare const writeJsonlAtomic: (filePath: string, values: readonly unknown[]) => Promise<void>;
+export declare const withAgentStateLock: <T>(cwd: string, operation: () => Promise<T>) => Promise<T>;
+export declare const tryWithAgentStateLock: <T>(cwd: string, operation: () => Promise<T>) => Promise<{
+    acquired: true;
+    result: T;
+} | {
+    acquired: false;
+}>;
+export declare const pathExists: (path: string) => Promise<boolean>;
+export declare const readPathMtimeMs: (path: string) => Promise<number>;