@allurereport/plugin-agent 3.13.2 → 3.14.1

package/dist/guidance.d.ts

@@ -8,10 +8,10 @@ export declare const ENRICHMENT_ACTIONS_BY_CHECK_NAME: Record<string, Enrichment
 export declare const AGENT_WORKFLOWS_MARKDOWN = "Use the smallest workflow that matches the task. Each workflow has the same shape: when to use it, which agent-mode commands help, and what must be true before you call the task done.\n\n### Validate A Change\n\nUse when code or tests changed and you need a user-facing safety conclusion. For small mechanical changes, use this same workflow with narrower expectations rather than a separate shortcut.\n\nCommands:\n\n- `allure agent --goal <text> --expect-* -- <command>`\n\nDone when:\n\n- the expected scope ran and no forbidden scope appeared\n- `index.md`, `manifest/run.json`, `manifest/tests.jsonl`, and `manifest/findings.jsonl` were reviewed\n- the `index.md` path was reported\n- the changed package build and required static checks passed when this repository guide requires them\n\n### Add Or Update Tests\n\nUse when creating or changing tests for a feature, fix, or behavior gap.\n\nCommands:\n\n- `allure agent --goal <text> --expect-tests <count> --expect-test \"<fullName>\" --expect-label name=value --expect-step-containing <text> -- <command>`\n\nDone when:\n\n- the tests prove the intended behavior rather than only touching the code path\n- scope expectations match the intended feature, issue, or package slice\n- each expected test has enough steps or attachments for a reviewer to understand what happened\n- weak evidence, scope drift, and unexpected-test findings are fixed or explicitly accepted as out of scope\n\n### Review Existing Coverage\n\nUse when auditing a package, command matrix, feature area, or business behavior without necessarily changing tests first.\n\nCommands:\n\n- one scoped `allure agent --goal <text> --expect-* -- <command>` run per review group\n- `allure agent inspect --goal <text> --expect-* <allure-results-dir-or-glob>` or `--dump <archive-or-glob>` when the evidence already exists as local results or CI dump artifacts\n\nDone when:\n\n- the audit is split into reviewable groups, or it is explicitly documented as a broad package-health run\n- each group has expectations that describe the intended scope\n- runtime artifacts are reviewed before source-only coverage conclusions\n- uncovered behavior is recorded as follow-up test work instead of being hidden in a broad pass/fail summary\n\n### Review Existing Evidence\n\nUse when CI has already produced dump archives or local Allure results already exist and you need agent-readable review artifacts without rerunning tests locally.\n\nCommands:\n\n- `allure agent inspect <allure-results-dir-or-glob>`\n- `allure agent inspect --dump <archive-or-glob>`\n- `allure agent inspect --dump <linux.zip> --dump <macos.zip>`\n- `allure agent inspect --goal <text> --expect-* --dump <archive-or-glob>`\n\nDone when:\n\n- all intended result directories or dump artifacts were downloaded or present and matched by the command\n- `index.md`, `manifest/run.json`, `manifest/tests.jsonl`, and `manifest/findings.jsonl` were reviewed\n- the review calls out that inspect-derived output cannot add missing live process logs or rerun-time evidence unless those artifacts were captured in the results or dumps\n- any environment-specific gaps between CI jobs are explicit\n\n### Triage Failures\n\nUse when tests failed, broke, or runner output does not match agent artifacts.\n\nCommands:\n\n- `allure agent latest`\n- `allure agent --rerun-latest --rerun-preset failed -- <command>`\n- `allure agent --rerun-from <output-dir> --rerun-preset failed -- <command>`\n\nDone when:\n\n- failing, broken, or unmodeled runner-visible failures are represented in agent artifacts, or partial modeling is called out explicitly\n- `artifacts/global/stderr.txt` and global errors were checked when failures are missing from `manifest/tests.jsonl`\n- reruns use prior agent output instead of hand-built runner test names whenever the runner can consume the generated test plan\n\n### Rerun A Prior Scope\n\nUse when prior agent output already identifies failed, unsuccessful, or review-targeted tests and the next run should stay focused.\n\nCommands:\n\n- `allure agent select --latest [--preset review|failed|unsuccessful|all]`\n- `allure agent select --from <output-dir> [--environment <id>] [--label name=value]`\n- `allure agent --rerun-latest -- <command>`\n- `allure agent --rerun-from <output-dir> -- <command>`\n\nDone when:\n\n- the rerun scope comes from Allure testplan support\n- `--rerun-preset`, `--rerun-environment`, or `--rerun-label` filters explain any narrowed selection\n- manual test names are used only as a fallback when testplan support is unavailable\n- the rerun output is reviewed before making a new conclusion\n\n### Improve Evidence Quality\n\nUse when tests pass or fail but the runtime story is too weak to review.\n\nCommands:\n\n- `allure agent --expect-step-containing <text> --expect-steps <count> --expect-attachments <count> -- <command>`\n- `allure agent --expect-attachment <name|name=value|content-type=value> -- <command>`\n\nDone when:\n\n- steps describe real setup, actions, state transitions, or assertions\n- attachments contain runtime evidence such as payloads, responses, screenshots, DOM snapshots, diffs, logs, or traces\n- placeholder steps, generic `\"passed\"` attachments, and other dummy evidence are removed\n- the same intended scope was rerun and no high-confidence evidence findings remain\n\n### Recover Or Diagnose Agent Mode\n\nUse when agent output is missing, the latest run cannot be found, local CLI support is unclear, or state behaves differently in CI or a sandbox.\n\nCommands:\n\n- `allure --version`\n- `allure agent capabilities --json`\n- `allure agent --help`\n- `allure agent latest`\n- `allure agent state-dir`\n- `ALLURE_AGENT_STATE_DIR=<dir>`\n\nDone when:\n\n- supported local commands and flags are known from capabilities or help output\n- the output directory, `index.md` path, or state directory is identified, or the reason it is unavailable is documented\n- console-only conclusions stay provisional until agent-mode artifacts are available";
 export declare const AGENT_COMMAND_TASK_MAP: readonly ["`allure --version`, `allure agent capabilities --json`, and `allure agent --help`: setup and capability-detection loop. Use when the local CLI surface is unknown, generated guidance may be stale, or you need to choose supported flags without guessing.", "`allure agent --goal ... -- <command>`: test review, feature delivery, smoke-check, and coverage loops. Use when a test command needs runtime evidence, scope expectations, and user-facing conclusions based on agent artifacts rather than console output alone. The default `--report auto` may also write a human-readable `awesome/index.html` for small runs.", "`allure agent inspect <allure-results-dir-or-glob>` / `allure agent inspect --dump <archive-or-glob>`: existing evidence review loop. Use after downloading one or more dump archives or when Allure results already exist and you need agent-readable markdown, manifests, and optional human report output without rerunning tests locally. Repeat `--dump` to merge multiple environments or jobs.", "`allure agent latest`: output recovery loop. Use when a previous run omitted `--output`, you need the newest output directory and `index.md` path, a user asks for the human-readable report from the last run, or a follow-up task needs prior output before selecting or rerunning tests.", "`allure agent state-dir`: tooling diagnosis loop. Use when `latest` cannot find a run, CI or sandbox state looks wrong, or you need to explain where per-project run registries are stored.", "`allure agent query --latest summary|tests|findings|test` / `allure agent query --from <output-dir> ...`: output inspection loop. Use when you need a focused JSON summary, human-report status, filtered tests, filtered findings, or one test from prior agent output without manually loading raw manifests first.", "`allure agent select --latest` / `allure agent select --from <output-dir>`: rerun-planning loop. Use when you need to inspect, filter, or write the Allure test plan from prior results before executing another run. Without `--output`, stdout is raw testplan JSON; with `--output`, stdout summarizes the file path, source output, preset, and selected count.", "`allure agent --rerun-latest` / `allure agent --rerun-from <output-dir>`: focused retry loop. Use when prior output already identifies failed, unsuccessful, or review-targeted tests and you should rerun that slice through Allure testplan support instead of rebuilding runner-specific test names.", "`ALLURE_AGENT_STATE_DIR=<dir>`: CI and sandbox state-control loop. Use when multiple jobs need a deterministic state location, the default temp state is not shared, or the default state directory is not writable."];
 export declare const AGENT_VERIFICATION_RULES: readonly ["If a command executes tests and its result will be used for smoke checking, reasoning, review, coverage analysis, debugging, or any user-facing conclusion, run it through `allure agent`. It preserves the original console logs and adds agent-mode artifacts without inheriting the normal report or export plugins from the project config.", "Use `allure agent` for smoke checks too, even when the change is small or mechanical.", "Only skip agent mode when it is impossible or when you are debugging agent mode itself.", "After changing a package in this repository, run that package build command before finalizing (for example, `yarn workspace <package-name> build`).", "After each agent-mode test run, print the `index.md` path from that run's output directory so users can open the run overview quickly."];
-export declare const AGENT_TEST_ENRICHMENT_BEST_PRACTICES: readonly ["Steps must wrap real actions, state transitions, or assertions. Prefer a small setup/action/assertion narrative over event-by-event step spam.", "Attachments must capture real runtime evidence from that execution: payloads, responses, screenshots, DOM snapshots, diffs, logs, or traces.", "Add metadata only when it improves scope review, debugging, or downstream policy. Keep labels and parameters intentionally minimal.", "If multiple call sites need the same evidence, instrument the helper once. Example: teach `runCommand` to emit a step instead of wrapping every `runCommand(...)` call site with identical step blocks."];
+export declare const AGENT_TEST_ENRICHMENT_BEST_PRACTICES: readonly ["Steps should wrap real actions, state transitions, or assertions; let the test's nature decide how granular they are.", "Attachments must capture real runtime evidence from that execution: payloads, responses, screenshots, DOM snapshots, diffs, logs, or traces.", "Add metadata only when it improves scope review, debugging, or downstream policy. Keep labels and parameters intentionally minimal.", "If multiple call sites need the same evidence, instrument the helper once. Example: teach `runCommand` to emit a step instead of wrapping every `runCommand(...)` call site with identical step blocks."];
 export declare const AGENT_ANTI_DUMMY_POLICY: readonly ["Do not add empty wrapper steps, placeholder attachments, or generic strings such as `passed`, `success`, or static boilerplate.", "Do not attach evidence that is not grounded in the current test execution. Synthetic summaries are fine only when they are derived from real runtime artifacts.", "Do not inflate metadata with labels, stories, or severities that no expectation, review step, or policy actually uses."];
-export declare const AGENT_ACCEPTANCE_CHECKLIST: readonly ["The rerun matches the intended scope and does not trigger forbidden or unexpected-test findings.", "Each touched test shows enough evidence to explain what happened and what was verified.", "Retries include per-attempt diagnostics when the same test reruns.", "No high-confidence anti-dummy findings remain, especially `noop-dominated-steps` or low-signal `step-spam` traces."];
+export declare const AGENT_ACCEPTANCE_CHECKLIST: readonly ["The rerun matches the intended scope and does not trigger forbidden or unexpected-test findings.", "Each touched test shows enough evidence to explain what happened and what was verified.", "Retries include per-attempt diagnostics when the same test reruns."];
 export declare const AGENT_REVIEW_COMPLETENESS_CHECKLIST: readonly ["The relevant scope was run with agent mode unless that was impossible.", "Scoped reviews created expectations before the final rerun, unless the task was an intentionally broad package-health audit.", "The final conclusion was based on `manifest/run.json`, `manifest/test-events.jsonl`, `index.md`, `manifest/tests.jsonl`, and `manifest/findings.jsonl` rather than console output alone.", "Any missing or partial runtime modeling was called out explicitly before the review was considered complete."];
 export declare const AGENT_PARTIAL_RUNTIME_REVIEW_RULES: readonly ["Suite-load, import, or setup failures may appear only in `artifacts/global/stderr.txt` or global errors instead of `manifest/tests.jsonl`.", "If runner-visible failures are not represented as logical tests, inspect global stderr and treat the run as a partial runtime review, not a clean result set.", "Console-only conclusions stay provisional when agent output is missing, incomplete, or partially modeled."];
-export declare const AGENT_INSTRUCTIONS_TEMPLATE = "## Allure Agent Mode Instructions\n\n- If a command executes tests and its result will be used for smoke checking, reasoning, review, coverage analysis, debugging, or any user-facing conclusion, run it through `allure agent`. It preserves the original console logs and adds agent-mode artifacts without inheriting the normal report or export plugins from the project config.\n- Use `allure agent` for smoke checks too, even when the change is small or mechanical.\n- Only skip agent mode when it is impossible or when you are debugging agent mode itself.\n- After each agent-mode test run, print the `index.md` path from that run's output directory so users can open the run overview quickly.\n- Use `allure agent latest` to print the newest output directory and `index.md` path when `--output` was omitted.\n- When a user asks for the human-readable report from the last run, use `allure agent latest` first if the output directory is unknown, then check `manifest/human-report.json`; when its status is `generated`, use the path recorded there, usually `awesome/index.html`.\n- Use `allure agent capabilities --json` when you need structured supported-command, expectation, output, rerun, and unsupported-feature data without scraping help text.\n- Use `allure agent state-dir` to inspect the shared state directory that stores per-project run registries.\n- Use `allure agent latest`, `state-dir`, `query`, `select`, and `--rerun-*` according to their loop/task/problem mapping instead of treating them as interchangeable helper commands.\n- Use `allure agent inspect <allure-results-dir-or-glob>` or `allure agent inspect --dump <archive-or-glob>` when you need agent-readable markdown and manifests from existing Allure results without rerunning tests locally; repeat `--dump` for multiple CI jobs or environments.\n- Use `--report auto|off|awesome|config` to control human report output. The default `auto` mode writes `awesome/index.html` for 1000 or fewer stored visible logical results and records generated, skipped, disabled, or failed status in `manifest/human-report.json`.\n- Use `allure agent query --latest summary|tests|findings|test` or `allure agent query --from <output-dir> ...` to inspect prior output as focused JSON before manually opening raw manifests.\n- Use `allure agent select --latest` or `allure agent select --from <output-dir>` to inspect the review-targeted test plan before rerunning; add `--output <file>` when you want the CLI to write the plan and print a short selection summary.\n- Use `allure agent --rerun-latest -- <command>` or `allure agent --rerun-from <output-dir> -- <command>` to rerun only the selected tests.\n- When rerunning previous failures, use `allure agent --rerun-latest --rerun-preset failed -- <command>` or `allure agent --rerun-from <output-dir> --rerun-preset failed -- <command>` instead of manually rebuilding runner-specific test names.\n- Use `--rerun-preset review|failed|unsuccessful|all`, repeated `--rerun-environment <id>`, and repeated `--rerun-label name=value` when you need a narrower rerun selection from the previous output.\n- Use `ALLURE_AGENT_STATE_DIR` when you need to override the shared agent state directory for `latest`, `state-dir`, or `--rerun-latest`.\n- Prefer inline `allure agent` expectation flags such as `--goal`, `--expect-tests`, `--expect-test`, `--expect-label`, and `--expect-step-containing`; use `--expectations <file>` only when flags become awkward.\n- Run tests with `allure agent` and review `manifest/run.json`, `manifest/test-events.jsonl`, `index.md`, `manifest/tests.jsonl`, and `manifest/findings.jsonl`.\n- Enrich only the intended tests. Add real steps for real setup, actions, and assertions.\n- Attach only real runtime evidence such as payloads, responses, screenshots, DOM snapshots, diffs, logs, or traces.\n- Keep metadata minimal. Add labels or severity only when scope review, debugging, or quality policy uses them.\n- Instrument stable helpers when several call sites need the same evidence. For example, teach `runCommand` to emit a step instead of wrapping every caller.\n- Reject the rerun if scope drifts, evidence stays weak, or high-confidence noop-style findings remain.";
+export declare const AGENT_INSTRUCTIONS_TEMPLATE = "## Allure Agent Mode Instructions\n\n- If a command executes tests and its result will be used for smoke checking, reasoning, review, coverage analysis, debugging, or any user-facing conclusion, run it through `allure agent`. It preserves the original console logs and adds agent-mode artifacts without inheriting the normal report or export plugins from the project config.\n- Use `allure agent` for smoke checks too, even when the change is small or mechanical.\n- Only skip agent mode when it is impossible or when you are debugging agent mode itself.\n- After each agent-mode test run, print the `index.md` path from that run's output directory so users can open the run overview quickly.\n- Use `allure agent latest` to print the newest output directory and `index.md` path when `--output` was omitted.\n- When a user asks for the human-readable report from the last run, use `allure agent latest` first if the output directory is unknown, then check `manifest/human-report.json`; when its status is `generated`, use the path recorded there, usually `awesome/index.html`.\n- Use `allure agent capabilities --json` when you need structured supported-command, expectation, output, rerun, and unsupported-feature data without scraping help text.\n- Use `allure agent state-dir` to inspect the shared state directory that stores per-project run registries.\n- Use `allure agent latest`, `state-dir`, `query`, `select`, and `--rerun-*` according to their loop/task/problem mapping instead of treating them as interchangeable helper commands.\n- Use `allure agent inspect <allure-results-dir-or-glob>` or `allure agent inspect --dump <archive-or-glob>` when you need agent-readable markdown and manifests from existing Allure results without rerunning tests locally; repeat `--dump` for multiple CI jobs or environments.\n- Use `--report auto|off|awesome|config` to control human report output. The default `auto` mode writes `awesome/index.html` for 1000 or fewer stored visible logical results and records generated, skipped, disabled, or failed status in `manifest/human-report.json`.\n- Use `allure agent query --latest summary|tests|findings|test` or `allure agent query --from <output-dir> ...` to inspect prior output as focused JSON before manually opening raw manifests.\n- Use `allure agent select --latest` or `allure agent select --from <output-dir>` to inspect the review-targeted test plan before rerunning; add `--output <file>` when you want the CLI to write the plan and print a short selection summary.\n- Use `allure agent --rerun-latest -- <command>` or `allure agent --rerun-from <output-dir> -- <command>` to rerun only the selected tests.\n- When rerunning previous failures, use `allure agent --rerun-latest --rerun-preset failed -- <command>` or `allure agent --rerun-from <output-dir> --rerun-preset failed -- <command>` instead of manually rebuilding runner-specific test names.\n- Use `--rerun-preset review|failed|unsuccessful|all`, repeated `--rerun-environment <id>`, and repeated `--rerun-label name=value` when you need a narrower rerun selection from the previous output.\n- Use `ALLURE_AGENT_STATE_DIR` when you need to override the shared agent state directory for `latest`, `state-dir`, or `--rerun-latest`.\n- Prefer inline `allure agent` expectation flags such as `--goal`, `--expect-tests`, `--expect-test`, `--expect-label`, and `--expect-step-containing`; use `--expectations <file>` only when flags become awkward.\n- Run tests with `allure agent` and review `manifest/run.json`, `manifest/test-events.jsonl`, `index.md`, `manifest/tests.jsonl`, and `manifest/findings.jsonl`.\n- Enrich only the intended tests. Add real steps for real setup, actions, and assertions.\n- Attach only real runtime evidence such as payloads, responses, screenshots, DOM snapshots, diffs, logs, or traces.\n- Keep metadata minimal. Add labels or severity only when scope review, debugging, or quality policy uses them.\n- Instrument stable helpers when several call sites need the same evidence. For example, teach `runCommand` to emit a step instead of wrapping every caller.\n- Reject the rerun if scope drifts or evidence stays weak.";
 export declare const renderAgentsGuide: () => string;

package/dist/guidance.js

@@ -94,11 +94,6 @@ export const ENRICHMENT_ACTIONS_BY_CHECK_NAME = {
         title: "Repair logical test identity",
         guidance: "Use stable, unique history IDs so distinct logical tests do not collapse into one file.",
     },
-    "failed-without-useful-steps": {
-        category: "add-meaningful-steps",
-        title: "Add meaningful setup, action, and assertion steps",
-        guidance: "Wrap only real actions, state transitions, and checks in Allure steps before rerunning.",
-    },
     "expected-step-containing-missing": {
         category: "add-meaningful-steps",
         title: "Add or correct the expected step text",
@@ -119,41 +114,6 @@ export const ENRICHMENT_ACTIONS_BY_CHECK_NAME = {
         title: "Add the required attachment",
         guidance: "Attach the requested runtime artifact near the relevant action or assertion.",
     },
-    "failed-without-attachments": {
-        category: "add-test-attachments",
-        title: "Attach focused runtime evidence near the failure",
-        guidance: "Add real payloads, responses, screenshots, DOM snapshots, diffs, or logs near the failing point.",
-    },
-    "nontrivial-run-with-empty-trace": {
-        category: "add-meaningful-steps",
-        title: "Make the execution path observable",
-        guidance: "Expose the real setup, action, and verification path with steps or attachments on the next run.",
-    },
-    "retries-without-new-evidence": {
-        category: "add-retry-diagnostics",
-        title: "Capture what changes between retries",
-        guidance: "Add per-attempt diagnostics so retries show new evidence instead of repeating the same trace.",
-    },
-    "noop-dominated-steps": {
-        category: "collapse-low-signal-trace",
-        title: "Replace noop-style steps with real evidence",
-        guidance: "Keep only steps tied to real actions or checks, and replace bulk event spam with a compact artifact when needed.",
-    },
-    "step-spam": {
-        category: "collapse-low-signal-trace",
-        title: "Reduce low-signal step spam",
-        guidance: "Prefer a smaller set of meaningful steps plus one compact text attachment when the trace is mostly event logs.",
-    },
-    "global-only-artifacts": {
-        category: "add-test-attachments",
-        title: "Move evidence closer to the failing test",
-        guidance: "Use step-scoped or test-scoped attachments near the relevant failing action instead of relying only on global logs.",
-    },
-    "passed-without-observable-evidence": {
-        category: "add-meaningful-steps",
-        title: "Make the success path reviewable",
-        guidance: "Add a few real verification steps or attachments so the passing test shows what it proved.",
-    },
 };
 export const AGENT_WORKFLOWS_MARKDOWN = `Use the smallest workflow that matches the task. Each workflow has the same shape: when to use it, which agent-mode commands help, and what must be true before you call the task done.
 
@@ -308,7 +268,7 @@ export const AGENT_VERIFICATION_RULES = [
     "After each agent-mode test run, print the `index.md` path from that run's output directory so users can open the run overview quickly.",
 ];
 export const AGENT_TEST_ENRICHMENT_BEST_PRACTICES = [
-    "Steps must wrap real actions, state transitions, or assertions. Prefer a small setup/action/assertion narrative over event-by-event step spam.",
+    "Steps should wrap real actions, state transitions, or assertions; let the test's nature decide how granular they are.",
     "Attachments must capture real runtime evidence from that execution: payloads, responses, screenshots, DOM snapshots, diffs, logs, or traces.",
     "Add metadata only when it improves scope review, debugging, or downstream policy. Keep labels and parameters intentionally minimal.",
     "If multiple call sites need the same evidence, instrument the helper once. Example: teach `runCommand` to emit a step instead of wrapping every `runCommand(...)` call site with identical step blocks.",
@@ -322,7 +282,6 @@ export const AGENT_ACCEPTANCE_CHECKLIST = [
     "The rerun matches the intended scope and does not trigger forbidden or unexpected-test findings.",
     "Each touched test shows enough evidence to explain what happened and what was verified.",
     "Retries include per-attempt diagnostics when the same test reruns.",
-    "No high-confidence anti-dummy findings remain, especially `noop-dominated-steps` or low-signal `step-spam` traces.",
 ];
 export const AGENT_REVIEW_COMPLETENESS_CHECKLIST = [
     "The relevant scope was run with agent mode unless that was impossible.",
@@ -360,7 +319,7 @@ export const AGENT_INSTRUCTIONS_TEMPLATE = `## Allure Agent Mode Instructions
 - Attach only real runtime evidence such as payloads, responses, screenshots, DOM snapshots, diffs, logs, or traces.
 - Keep metadata minimal. Add labels or severity only when scope review, debugging, or quality policy uses them.
 - Instrument stable helpers when several call sites need the same evidence. For example, teach \`runCommand\` to emit a step instead of wrapping every caller.
-- Reject the rerun if scope drifts, evidence stays weak, or high-confidence noop-style findings remain.`;
+- Reject the rerun if scope drifts or evidence stays weak.`;
 const renderBullets = (items) => items.map((item) => `- ${item}`).join("\n");
 const renderRemediationGuide = () => Object.entries(ENRICHMENT_ACTIONS_BY_CHECK_NAME)
     .map(([checkName, action]) => `- \`${checkName}\`: ${action.title}. ${action.guidance}`)

package/dist/harness.d.ts

@@ -323,8 +323,8 @@ export type AgentReviewOptions = {
 export declare const DEFAULT_ANTI_DUMMY_CONFIDENCE = 0.75;
 export declare const AGENT_ENRICHMENT_ACTIONS: Record<string, AgentEnrichmentAction>;
 export declare const SCOPE_REJECTING_CHECKS: readonly ["expected-test-missing", "expected-count-mismatch", "expected-prefix-missing", "expected-label-missing", "expected-environment-missing", "no-tests-observed", "unexpected-environment", "forbidden-label-observed", "unexpected-test"];
-export declare const ITERATION_REQUIRED_CHECKS: readonly ["expectations-invalid", "expectations-empty", "expectations-unsupported-control", "runner-failures-outside-logical-results", "metadata-mismatch", "history-id-collision", "expected-step-containing-missing", "insufficient-expected-steps", "insufficient-expected-attachments", "missing-expected-attachment", "failed-without-useful-steps", "failed-without-attachments", "nontrivial-run-with-empty-trace", "retries-without-new-evidence", "passed-without-observable-evidence"];
-export declare const ANTI_DUMMY_CHECKS: readonly ["noop-dominated-steps"];
+export declare const ITERATION_REQUIRED_CHECKS: readonly ["expectations-invalid", "expectations-empty", "expectations-unsupported-control", "runner-failures-outside-logical-results", "metadata-mismatch", "history-id-collision", "expected-step-containing-missing", "insufficient-expected-steps", "insufficient-expected-attachments", "missing-expected-attachment"];
+export declare const ANTI_DUMMY_CHECKS: readonly string[];
 export declare const buildAgentExpectations: (input: AgentHarnessRequest) => AgentExpectations;
 export declare const mapFindingToEnrichmentAction: (finding: AgentFindingManifestLine | string) => AgentEnrichmentAction;
 export declare const loadAgentOutput: (outputDir: string) => Promise<AgentOutputBundle>;

package/dist/harness.js

@@ -1,6 +1,9 @@
 import { readFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import { AgentUsageError } from "./errors.js";
 import { ENRICHMENT_ACTIONS_BY_CHECK_NAME } from "./guidance.js";
+import { isPathInside } from "./paths.js";
+import { isFileNotFoundError } from "./utils.js";
 export const DEFAULT_ANTI_DUMMY_CONFIDENCE = 0.75;
 const FALLBACK_ACTION = {
     checkName: "*",
@@ -31,13 +34,8 @@ export const ITERATION_REQUIRED_CHECKS = [
     "insufficient-expected-steps",
     "insufficient-expected-attachments",
     "missing-expected-attachment",
-    "failed-without-useful-steps",
-    "failed-without-attachments",
-    "nontrivial-run-with-empty-trace",
-    "retries-without-new-evidence",
-    "passed-without-observable-evidence",
 ];
-export const ANTI_DUMMY_CHECKS = ["noop-dominated-steps"];
+export const ANTI_DUMMY_CHECKS = [];
 const SEVERITY_ORDER = {
     high: 0,
     warning: 1,
@@ -142,8 +140,7 @@ const impactForFinding = (finding, antiDummyConfidenceThreshold) => {
     if (SCOPE_REJECTING_CHECKS.includes(checkName)) {
         return "reject";
     }
-    if (ANTI_DUMMY_CHECKS.includes(checkName) &&
-        (finding.confidence ?? 0) >= antiDummyConfidenceThreshold) {
+    if (ANTI_DUMMY_CHECKS.includes(checkName) && (finding.confidence ?? 0) >= antiDummyConfidenceThreshold) {
         return "reject";
     }
     if (ITERATION_REQUIRED_CHECKS.includes(checkName)) {
@@ -171,16 +168,55 @@ export const mapFindingToEnrichmentAction = (finding) => {
     const mapped = AGENT_ENRICHMENT_ACTIONS[checkName];
     return mapped ?? { ...FALLBACK_ACTION, checkName };
 };
+const resolveContainedOutputPath = (outputDir, relativePath) => {
+    const resolved = join(outputDir, relativePath);
+    return isPathInside(outputDir, resolved) ? resolved : undefined;
+};
+const readAgentRunManifest = async (outputDir) => {
+    const runManifestPath = join(outputDir, "manifest", "run.json");
+    let raw;
+    try {
+        raw = await readFile(runManifestPath, "utf-8");
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            throw new AgentUsageError(`No Allure agent output found at ${JSON.stringify(outputDir)} (missing manifest/run.json). ` +
+                "It must be a directory created by a previous `allure agent` run. " +
+                "Run `allure agent latest` to find the most recent output, pass a valid --from <agent-output-dir> or --latest, " +
+                "or run `allure agent <command>` to create one.");
+        }
+        throw error;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new AgentUsageError(`The Allure agent output at ${JSON.stringify(outputDir)} is corrupted: manifest/run.json is not valid JSON. ` +
+            "Re-run `allure agent` to regenerate the output.");
+    }
+};
 export const loadAgentOutput = async (outputDir) => {
     const absoluteOutputDir = resolve(outputDir);
-    const run = await readJson(join(absoluteOutputDir, "manifest", "run.json"));
-    const tests = await readJsonl(join(absoluteOutputDir, "manifest", "tests.jsonl"));
-    const findings = await readJsonl(join(absoluteOutputDir, "manifest", "findings.jsonl"));
-    const expected = run.paths.expected_manifest && run.expectations_present
-        ? await readJson(join(absoluteOutputDir, run.paths.expected_manifest))
+    const run = await readAgentRunManifest(absoluteOutputDir);
+    let tests;
+    let findings;
+    try {
+        tests = await readJsonl(join(absoluteOutputDir, "manifest", "tests.jsonl"));
+        findings = await readJsonl(join(absoluteOutputDir, "manifest", "findings.jsonl"));
+    }
+    catch {
+        throw new AgentUsageError(`The Allure agent output at ${JSON.stringify(absoluteOutputDir)} is incomplete or corrupted: ` +
+            "its test/finding manifests could not be read. Re-run `allure agent` to regenerate the output.");
+    }
+    const expectedManifestPath = run.paths.expected_manifest && run.expectations_present
+        ? resolveContainedOutputPath(absoluteOutputDir, run.paths.expected_manifest)
         : undefined;
-    const humanReport = run.paths.human_report_manifest
-        ? await readJson(join(absoluteOutputDir, run.paths.human_report_manifest))
+    const expected = expectedManifestPath ? await readJson(expectedManifestPath) : undefined;
+    const humanReportManifestPath = run.paths.human_report_manifest
+        ? resolveContainedOutputPath(absoluteOutputDir, run.paths.human_report_manifest)
+        : undefined;
+    const humanReport = humanReportManifestPath
+        ? await readJson(humanReportManifestPath)
         : undefined;
     return {
         outputDir: absoluteOutputDir,
@@ -223,9 +259,6 @@ export const planAgentEnrichmentReview = (output, options = {}) => {
     if (!output.run.expectations_present) {
         notes.push("Declare inline expectations or provide an expectations file before the next enrichment iteration so scope checks are comparable.");
     }
-    if (rejecting.some((item) => item.checkName === "noop-dominated-steps")) {
-        notes.push("Reject noop-dominated enrichment: keep only steps tied to real actions or checks, and use real runtime attachments instead of placeholders.");
-    }
     if (rejecting.some((item) => SCOPE_REJECTING_CHECKS.includes(item.checkName))) {
         notes.push("Reject scope drift: rerun only the intended tests and keep forbidden scope in the expectations file.");
     }

package/dist/index.d.ts

@@ -4,8 +4,10 @@ export * from "./errors.js";
 export * from "./harness.js";
 export * from "./inline-expectations.js";
 export * from "./invalid-output.js";
+export * from "./output-dir.js";
 export * from "./paths.js";
 export * from "./query.js";
 export * from "./selection.js";
 export * from "./state.js";
+export * from "./summary.js";
 export { AgentPlugin as default } from "./plugin.js";

package/dist/index.js

@@ -4,8 +4,10 @@ export * from "./errors.js";
 export * from "./harness.js";
 export * from "./inline-expectations.js";
 export * from "./invalid-output.js";
+export * from "./output-dir.js";
 export * from "./paths.js";
 export * from "./query.js";
 export * from "./selection.js";
 export * from "./state.js";
+export * from "./summary.js";
 export { AgentPlugin as default } from "./plugin.js";

package/dist/inline-expectations.js

@@ -44,12 +44,12 @@ const readSingleStringOption = (value, optionName) => {
     return normalized;
 };
 const parseNameValue = (value, optionName, example) => {
-    const parts = value.split("=");
-    if (parts.length !== 2) {
+    const separatorIndex = value.indexOf("=");
+    if (separatorIndex === -1) {
         throw new AgentExpectationUsageError(`Invalid ${optionName} ${JSON.stringify(value)}. Expected ${example}`, optionName);
     }
-    const name = parts[0].trim();
-    const filterValue = parts[1].trim();
+    const name = value.slice(0, separatorIndex).trim();
+    const filterValue = value.slice(separatorIndex + 1).trim();
     if (!name || !filterValue) {
         throw new AgentExpectationUsageError(`Invalid ${optionName} ${JSON.stringify(value)}. Expected ${example}`, optionName);
     }

package/dist/output-dir.d.ts

@@ -0,0 +1 @@
+export declare const assertExplicitAgentOutputDirIsSafe: (outputDir: string) => Promise<void>;

package/dist/output-dir.js

@@ -0,0 +1,22 @@
+import { readdir, stat } from "node:fs/promises";
+import { AgentUsageError } from "./errors.js";
+import { isFileNotFoundError } from "./utils.js";
+export const assertExplicitAgentOutputDirIsSafe = async (outputDir) => {
+    let stats;
+    try {
+        stats = await stat(outputDir);
+    }
+    catch (error) {
+        if (isFileNotFoundError(error)) {
+            return;
+        }
+        throw error;
+    }
+    if (!stats.isDirectory()) {
+        throw new AgentUsageError(`--output ${JSON.stringify(outputDir)} is not a directory; use a new or empty directory`);
+    }
+    if ((await readdir(outputDir)).length > 0) {
+        throw new AgentUsageError(`refusing to use --output ${JSON.stringify(outputDir)}: the agent recursively deletes its output directory, ` +
+            `so it must be a new or empty directory.`);
+    }
+};

package/dist/plugin.js

@@ -31,8 +31,6 @@ const FINDING_SEVERITY_ORDER = {
     info: 2,
 };
 const NONTRIVIAL_DURATION_MS = 100;
-const STEP_SPAM_THRESHOLD = 25;
-const NOOP_RATIO_THRESHOLD = 0.8;
 const ASSERTION_STEP_PATTERN = /\b(assert|expect|check|verify|validate|should)\b/i;
 const LOW_VALUE_STDERR_WARNING_PATTERNS = [
     /\bNO_COLOR\b/i,
@@ -98,7 +96,6 @@ const sortByNewestAttempt = (items) => [...items].sort((left, right) => {
 const formatTimestamp = (value) => (value === undefined ? "unknown" : new Date(value).toISOString());
 const formatDurationValue = (value) => formatDuration(value);
 const escapeJsonPointerSegment = (value) => value.replace(/~/g, "~0").replace(/\//g, "~1");
-const isFailedLikeStatus = (status) => status === "failed" || status === "broken";
 const normalizeStringArray = (value) => {
     if (!Array.isArray(value)) {
         return [];
@@ -251,10 +248,12 @@ const analyzeStepTree = (steps) => {
             if (hasNestedSteps) {
                 summary.nestedSteps += 1;
             }
-            if (ASSERTION_STEP_PATTERN.test(node.name)) {
+            const isAssertionLike = ASSERTION_STEP_PATTERN.test(node.name);
+            const isNonTrivialDuration = (node.duration ?? 0) >= NONTRIVIAL_DURATION_MS;
+            if (isAssertionLike) {
                 summary.assertionLikeSteps += 1;
             }
-            if (hasEvidence) {
+            if (hasEvidence || isAssertionLike || isNonTrivialDuration) {
                 summary.meaningfulSteps += 1;
             }
             else {
@@ -304,17 +303,6 @@ const testStepContainsText = (entry, expectedText) => {
     }
     return collectStepNames(entry.attempts[0].tr.steps).some(({ name }) => normalizeStepText(name).includes(expected));
 };
-const buildAttemptSignature = (attempt) => JSON.stringify({
-    status: attempt.tr.status,
-    errorMessage: attempt.tr.error?.message,
-    errorTrace: attempt.tr.error?.trace,
-    stepSummary: attempt.stepSummary,
-    fixtureSummary: attempt.fixtureStepSummary,
-    artifactNames: attempt.artifacts.map((artifact) => ({
-        name: artifact.displayName,
-        missing: artifact.missing,
-    })),
-});
 const getPackageName = (tr) => tr.labels.find(({ name }) => name === "package")?.value;
 const toLabelEntries = (labels) => labels.map((label) => ({
     name: label.name,
@@ -1028,9 +1016,6 @@ const defaultImpactForFinding = (finding) => {
     ].includes(finding.checkName)) {
         return "reject";
     }
-    if (finding.checkName === "noop-dominated-steps" && (finding.confidence ?? 0) >= 0.75) {
-        return "reject";
-    }
     if ([
         "expectations-invalid",
         "expectations-empty",
@@ -1043,11 +1028,6 @@ const defaultImpactForFinding = (finding) => {
         "runner-failures-outside-logical-results",
         "metadata-mismatch",
         "history-id-collision",
-        "failed-without-useful-steps",
-        "failed-without-attachments",
-        "nontrivial-run-with-empty-trace",
-        "retries-without-new-evidence",
-        "passed-without-observable-evidence",
     ].includes(finding.checkName)) {
         return "iterate";
     }
@@ -1247,7 +1227,7 @@ const renderExpectationResultSection = (params) => {
     ].join("\n");
 };
 const renderRerunGuidance = (findings) => {
-    const relevant = findings.filter(({ category }) => category === "evidence" || category === "smells" || category === "metadata");
+    const relevant = findings.filter(({ category }) => category === "evidence" || category === "metadata");
     if (!relevant.length) {
         return undefined;
     }
@@ -1260,9 +1240,6 @@ const renderRerunGuidance = (findings) => {
     if (relevant.some(({ category }) => category === "metadata")) {
         lines.push("- Add or repair the labels and parameters needed to identify the intended scope.");
     }
-    if (relevant.some(({ checkName }) => checkName === "noop-dominated-steps")) {
-        lines.push("- Replace repetitive event-style steps with a compact text attachment when the signal is mostly logs.");
-    }
     lines.push("- Rerun only the relevant tests with the same expectations so the next review is scoped and comparable.");
     return lines.join("\n");
 };
@@ -1832,7 +1809,7 @@ const computeScopeEvaluation = (params) => {
             scopeMatch: "forbidden",
             reasons: forbidden.reasons,
             expectedReferences: forbidden.references,
-            metadataMismatches,
+            metadataMismatches: [],
         };
     }
     if (!positivePresent) {
@@ -1864,18 +1841,9 @@ const buildDurationSummary = (entries) => {
     return {
         total,
         average: durations.length ? Math.round(total / durations.length) : 0,
-        max: durations.length ? Math.max(...durations) : 0,
+        max: durations.reduce((acc, value) => (value > acc ? value : acc), 0),
     };
 };
-const collectTestEvidencePaths = (entry) => {
-    const paths = [entry.relativePath];
-    for (const artifact of entry.allArtifacts) {
-        if (artifact.relativePath) {
-            paths.push(artifact.relativePath);
-        }
-    }
-    return uniqueValues(paths);
-};
 const getExpectationTargetEntries = (entries, expectations) => {
     if (!hasSelector(expectations.expected)) {
         return entries;
@@ -2162,18 +2130,11 @@ const buildRunAndTestFindings = (params) => {
         ? new Set(getExpectationTargetEntries(entries, expectations).map((entry) => entry.key))
         : new Set();
     for (const entry of entries) {
-        const currentAttempt = entry.attempts[0];
-        const attemptSignatures = uniqueValues(entry.attempts.map(buildAttemptSignature));
-        const testEvidencePaths = collectTestEvidencePaths(entry);
-        const allStepSummary = mergeStepSummaries(entry.attempts.map((attempt) => mergeStepSummaries([attempt.stepSummary, attempt.fixtureStepSummary])));
         const expectedEvidenceApplies = expectations ? evidenceTargetKeys.has(entry.key) : false;
         const expectedEvidence = expectations?.evidence;
         const currentStepSummary = currentAttemptStepSummary(entry);
         const currentMeaningfulSteps = currentStepSummary.meaningfulSteps;
         const currentAttachments = nonMissingArtifacts(entry);
-        const hasUsefulSteps = currentAttempt.stepSummary.meaningfulSteps + currentAttempt.fixtureStepSummary.meaningfulSteps > 0;
-        const hasAnyAttachments = entry.allArtifacts.some((artifact) => !artifact.missing);
-        const noopRatio = allStepSummary.totalSteps > 0 ? allStepSummary.noopSteps / allStepSummary.totalSteps : 0;
         if (entry.scope.scopeMatch === "forbidden") {
             const forbiddenLabelReference = entry.scope.expectedReferences.find((reference) => reference.startsWith("forbidden.label_values"));
             const checkName = forbiddenLabelReference ? "forbidden-label-observed" : "forbidden-selector-match";
@@ -2364,124 +2325,6 @@ const buildRunAndTestFindings = (params) => {
                 confidence: 0.95,
             }));
         });
-        if (isFailedLikeStatus(currentAttempt.tr.status) && !hasUsefulSteps) {
-            entry.findings.push(createFinding({
-                subject: entry.key,
-                subjectType: "test",
-                severity: "warning",
-                category: "evidence",
-                checkName: "failed-without-useful-steps",
-                message: "A failed or broken test has no useful runtime steps.",
-                explanation: "The failure is recorded, but the step tree does not explain the state transitions that led to it.",
-                evidencePaths: testEvidencePaths,
-                remediationHint: "Add meaningful steps around the important actions and checks before rerunning.",
-                confidence: 0.92,
-            }));
-        }
-        if (isFailedLikeStatus(currentAttempt.tr.status) && !hasAnyAttachments) {
-            entry.findings.push(createFinding({
-                subject: entry.key,
-                subjectType: "test",
-                severity: "warning",
-                category: "evidence",
-                checkName: "failed-without-attachments",
-                message: "A failed or broken test has no test-scoped attachments.",
-                explanation: "Attachments often provide the fastest route to understanding why the test failed.",
-                evidencePaths: testEvidencePaths,
-                remediationHint: "Attach targeted logs, payloads, screenshots, or DOM snapshots around the failing point.",
-                confidence: 0.88,
-            }));
-        }
-        if ((currentAttempt.tr.duration ?? 0) >= NONTRIVIAL_DURATION_MS &&
-            currentAttempt.stepSummary.totalSteps === 0 &&
-            currentAttempt.fixtureStepSummary.totalSteps === 0) {
-            entry.findings.push(createFinding({
-                subject: entry.key,
-                subjectType: "test",
-                severity: "warning",
-                category: "evidence",
-                checkName: "nontrivial-run-with-empty-trace",
-                message: "A nontrivial test run recorded no steps or fixture activity.",
-                explanation: "The duration suggests real work happened, but the trace contains no step-level evidence.",
-                evidencePaths: testEvidencePaths,
-                remediationHint: "Add runtime steps or attachments so the execution path is observable on the next run.",
-                confidence: 0.8,
-            }));
-        }
-        if (entry.attempts.length > 1 && attemptSignatures.length === 1) {
-            entry.findings.push(createFinding({
-                subject: entry.key,
-                subjectType: "test",
-                severity: "info",
-                category: "evidence",
-                checkName: "retries-without-new-evidence",
-                message: "Retries did not add any new observable evidence.",
-                explanation: "The recorded status, error, steps, and attachments stayed effectively unchanged across retries.",
-                evidencePaths: testEvidencePaths,
-                remediationHint: "Add retry-specific diagnostics or targeted attachments so reruns can show what changed.",
-                confidence: 0.7,
-            }));
-        }
-        if (allStepSummary.totalSteps >= 3 && noopRatio >= NOOP_RATIO_THRESHOLD && !hasAnyAttachments) {
-            entry.findings.push(createFinding({
-                subject: entry.key,
-                subjectType: "test",
-                severity: "warning",
-                category: "smells",
-                checkName: "noop-dominated-steps",
-                message: "The step tree is dominated by low-signal steps.",
-                explanation: "Most recorded steps are leaf steps without parameters, nested actions, attachments, or error context.",
-                evidencePaths: testEvidencePaths,
-                remediationHint: "Collapse repetitive event-style steps into a smaller set of meaningful steps or attach a text log instead.",
-                confidence: 0.75,
-            }));
-        }
-        if (allStepSummary.totalSteps >= STEP_SPAM_THRESHOLD && !hasAnyAttachments) {
-            entry.findings.push(createFinding({
-                subject: entry.key,
-                subjectType: "test",
-                severity: "info",
-                category: "smells",
-                checkName: "step-spam",
-                message: "The trace records many steps but no compact artifact.",
-                explanation: "A large number of small steps can be harder to review than a focused log attachment.",
-                evidencePaths: testEvidencePaths,
-                remediationHint: "Consider attaching a structured text log when the trace is mostly event reporting.",
-                confidence: 0.7,
-            }));
-        }
-        if (isFailedLikeStatus(currentAttempt.tr.status) && !hasAnyAttachments && globalArtifacts.length > 0) {
-            entry.findings.push(createFinding({
-                subject: entry.key,
-                subjectType: "test",
-                severity: "info",
-                category: "smells",
-                checkName: "global-only-artifacts",
-                message: "Only run-level artifacts are available for this failed test.",
-                explanation: "The run captured global logs, but the failed test has no test-scoped attachments to pinpoint the failure.",
-                evidencePaths: uniqueValues(testEvidencePaths.concat(globalArtifacts.flatMap((artifact) => (artifact.relativePath ? [artifact.relativePath] : [])))),
-                remediationHint: "Prefer step-scoped or test-scoped attachments near the failing action when debugging targeted failures.",
-                confidence: 0.78,
-            }));
-        }
-        if (currentAttempt.tr.status === "passed" &&
-            (currentAttempt.tr.duration ?? 0) >= NONTRIVIAL_DURATION_MS &&
-            currentAttempt.stepSummary.totalSteps === 0 &&
-            currentAttempt.fixtureStepSummary.totalSteps === 0 &&
-            !hasAnyAttachments) {
-            entry.findings.push(createFinding({
-                subject: entry.key,
-                subjectType: "test",
-                severity: "info",
-                category: "smells",
-                checkName: "passed-without-observable-evidence",
-                message: "A nontrivial passing test recorded no observable evidence.",
-                explanation: "The test passed, but the agentic output contains no steps, fixture activity, or attachments showing what was verified.",
-                evidencePaths: testEvidencePaths,
-                remediationHint: "Add a few meaningful verification steps or attachments so the success path is reviewable.",
-                confidence: 0.65,
-            }));
-        }
     }
     return {
         runFindings,

package/dist/query.js

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import { AgentUsageError } from "./errors.js";
+import { isPathInside } from "./paths.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"];
@@ -83,7 +84,13 @@ const filterAgentQueryFindings = (output, filters) => {
         .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 resolveAgentOutputPath = (output, relativePath) => {
+    if (!relativePath) {
+        return null;
+    }
+    const resolved = join(output.outputDir, relativePath);
+    return isPathInside(output.outputDir, resolved) ? resolved : null;
+};
 const buildAgentQuerySummaryPayload = (output) => ({
     schema: AGENT_QUERY_SCHEMA,
     view: "summary",
@@ -153,6 +160,16 @@ const buildAgentQueryTestPayload = async (output, filters) => {
     const test = matched[0];
     const markdownPath = resolveAgentOutputPath(output, test.markdown_path);
     const findings = output.findings.filter((finding) => agentFindingSubjectRef(finding) === test.markdown_path);
+    let markdown;
+    if (filters.includeMarkdown && markdownPath) {
+        try {
+            markdown = await readFile(markdownPath, "utf-8");
+        }
+        catch {
+            throw new AgentUsageError(`Could not read the per-test markdown for ${JSON.stringify(test.full_name)} at ${JSON.stringify(markdownPath)}; ` +
+                "the agent output is incomplete. Re-run `allure agent` to regenerate it, or omit --include-markdown.");
+        }
+    }
     return {
         schema: AGENT_QUERY_SCHEMA,
         view: "test",
@@ -160,7 +177,7 @@ const buildAgentQueryTestPayload = async (output, filters) => {
         markdown_path: markdownPath,
         test,
         findings,
-        ...(filters.includeMarkdown && markdownPath ? { markdown: await readFile(markdownPath, "utf-8") } : {}),
+        ...(markdown !== undefined ? { markdown } : {}),
     };
 };
 export const buildAgentQueryPayload = async (output, view, filters) => {

package/dist/selection.js

@@ -90,7 +90,8 @@ export const resolveAgentSelectionOutputDir = async (params) => {
     }
     const latestState = await readLatestAgentState(cwd);
     if (!latestState) {
-        throw new AgentUsageError(`No latest agent output found for ${cwd}`);
+        throw new AgentUsageError(`No recorded Allure agent output for ${JSON.stringify(cwd)}. ` +
+            "Run `allure agent <command>` first to create one, or pass --from <agent-output-dir>.");
     }
     return latestState.outputDir;
 };

package/dist/state.d.ts

@@ -47,6 +47,8 @@ export declare const cleanupAgentRunState: (params: {
     cwd: string;
     currentRunId?: string;
     keepManagedRuns?: number;
+    managedOutputGraceMs?: number;
+    now?: number;
 }) => Promise<AgentStateCleanupResult>;
 export declare const cleanupStaleAgentRunStates: (params: {
     cwd: string;

package/dist/state.js

@@ -1,9 +1,11 @@
 import { appendFile, readFile, rm } from "node:fs/promises";
 import { join, resolve } from "node:path";
+import process from "node:process";
 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 AGENT_MANAGED_OUTPUT_GRACE_MS = 60 * 60 * 1000;
 const isAgentRunState = (value) => {
     if (typeof value !== "object" || value === null) {
         return false;
@@ -86,7 +88,17 @@ const foldAgentRunStates = (states) => {
         .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 isProcessAlive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+};
+const isAgentRunActive = (state) => state.status === "running" && state.pid !== undefined && isProcessAlive(state.pid);
+const isManagedOutputStale = (state, now, staleOutputTtlMs) => state.managedOutput && !isAgentRunActive(state) && 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));
@@ -181,6 +193,8 @@ export const readLatestAgentState = async (cwd) => {
 };
 export const cleanupAgentRunState = async (params) => withAgentStateLock(params.cwd, async () => {
     const keepManagedRuns = Math.max(0, params.keepManagedRuns ?? 1);
+    const managedOutputGraceMs = Math.max(0, params.managedOutputGraceMs ?? AGENT_MANAGED_OUTPUT_GRACE_MS);
+    const now = params.now ?? Date.now();
     const states = foldAgentRunStates(await readAgentRunStateLines(params.cwd));
     const existing = [];
     for (const state of states) {
@@ -202,6 +216,9 @@ export const cleanupAgentRunState = async (params) => withAgentStateLock(params.
         if (!state.managedOutput || state.status !== "finished" || retainedManagedRunIds.has(state.runId)) {
             continue;
         }
+        if (now - (state.finishedAt ?? state.startedAt) <= managedOutputGraceMs) {
+            continue;
+        }
         try {
             await rm(state.outputDir, { recursive: true, force: true });
             deleted.push(state);

package/dist/summary.d.ts

@@ -0,0 +1,9 @@
+import type { AgentRunManifest } from "./harness.js";
+import type { AgentHumanReportStatus } from "./model.js";
+export declare const formatAgentRunSummary: (params: {
+    outputDir: string;
+    run: AgentRunManifest;
+    humanReport?: AgentHumanReportStatus | null;
+    durationMs?: number;
+    rerunCommand?: string;
+}) => string[];

package/dist/summary.js

@@ -0,0 +1,73 @@
+import { join } from "node:path";
+const formatStatusCounts = (stats) => {
+    const parts = [
+        stats.failed ? `${stats.failed} failed` : undefined,
+        stats.broken ? `${stats.broken} broken` : undefined,
+        stats.passed ? `${stats.passed} passed` : undefined,
+        stats.skipped ? `${stats.skipped} skipped` : undefined,
+        stats.unknown ? `${stats.unknown} unknown` : undefined,
+    ].filter((part) => part !== undefined);
+    const total = stats.total ?? 0;
+    return `${parts.length ? parts.join(", ") : "no tests"} (${total} total)`;
+};
+const formatDurationMs = (ms) => {
+    if (ms < 1000) {
+        return `${Math.round(ms)}ms`;
+    }
+    const seconds = ms / 1000;
+    if (seconds < 60) {
+        return `${seconds.toFixed(1)}s`;
+    }
+    const minutes = Math.floor(seconds / 60);
+    const remainingSeconds = Math.round(seconds % 60);
+    return `${minutes}m ${remainingSeconds}s`;
+};
+const formatFindingCounts = (countsBySeverity) => [
+    countsBySeverity.high ? `${countsBySeverity.high} high` : undefined,
+    countsBySeverity.warning ? `${countsBySeverity.warning} warning` : undefined,
+    countsBySeverity.info ? `${countsBySeverity.info} info` : undefined,
+]
+    .filter((part) => part !== undefined)
+    .join(", ");
+export const formatAgentRunSummary = (params) => {
+    const { outputDir, run } = params;
+    const humanReport = params.humanReport ?? run.human_report ?? undefined;
+    const toAbsolute = (relativePath) => (relativePath ? join(outputDir, relativePath) : undefined);
+    const lines = [];
+    const exitCode = run.actual_exit_code ?? run.original_exit_code;
+    const flaky = run.summary.stats.flaky ?? 0;
+    const failedCount = (run.summary.stats.failed ?? 0) + (run.summary.stats.broken ?? 0);
+    lines.push(`Allure agent: ${formatStatusCounts(run.summary.stats)} · exit ${exitCode ?? "unknown"}` +
+        (params.durationMs !== undefined ? ` · ${formatDurationMs(params.durationMs)}` : "") +
+        (flaky ? ` · ${flaky} flaky` : ""));
+    if (run.check_summary.total > 0) {
+        lines.push(`  findings: ${run.check_summary.total} (${formatFindingCounts(run.check_summary.countsBySeverity)}) — a green count is not a pass`);
+    }
+    if (run.expectations_present) {
+        lines.push(`  expectations: ${run.expectation_result.status} (${run.expectation_result.impact})`);
+    }
+    if (run.modeling?.completeness === "partial") {
+        lines.push("  runtime modeling: partial — some runner failures are outside logical tests; check stderr");
+    }
+    if (params.rerunCommand && failedCount > 0) {
+        lines.push(`  rerun failed: allure agent --rerun-from ${outputDir} --rerun-preset failed -- ${params.rerunCommand}` +
+            `  (reruns ${failedCount} failed test${failedCount === 1 ? "" : "s"})`);
+    }
+    lines.push("");
+    lines.push("Reach every conclusion from this agent output, not the raw console:");
+    lines.push(`  overview   ${toAbsolute(run.paths.index_md)}  (read this first)`);
+    lines.push(`  findings   ${toAbsolute(run.paths.findings_manifest)}`);
+    lines.push(`  tests      ${toAbsolute(run.paths.tests_manifest)}`);
+    const logs = [toAbsolute(run.paths.process_logs.stdout), toAbsolute(run.paths.process_logs.stderr)].filter((value) => value !== undefined);
+    if (logs.length) {
+        lines.push(`  test logs  ${logs.join("  ")}`);
+    }
+    lines.push(`  run data   ${join(outputDir, "manifest", "run.json")}`);
+    lines.push(`  guide      ${toAbsolute(run.paths.agents_md)}`);
+    lines.push(`  inspect    allure agent query --from ${outputDir} summary|tests|findings|test`);
+    const reportPath = humanReport?.status === "generated" ? toAbsolute(humanReport.path) : undefined;
+    if (reportPath) {
+        lines.push(`Here is the report: [report](${reportPath})`);
+    }
+    return lines;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@allurereport/plugin-agent",
-  "version": "3.13.2",
+  "version": "3.14.1",
   "description": "Allure Agent Plugin – AI-friendly markdown report generator",
   "keywords": [
     "agent",
@@ -31,12 +31,12 @@
     "lint:fix": "yarn run -T oxlint --import-plugin --fix src test features stories"
   },
   "dependencies": {
-    "@allurereport/core-api": "3.13.2",
-    "@allurereport/plugin-api": "3.13.2",
+    "@allurereport/core-api": "3.14.1",
+    "@allurereport/plugin-api": "3.14.1",
     "yaml": "^2.8.1"
   },
   "devDependencies": {
-    "@allurereport/reader-api": "3.13.2",
+    "@allurereport/reader-api": "3.14.1",
     "@types/node": "^20",
     "@vitest/runner": "^2",
     "allure-js-commons": "^3",