@skyramp/mcp 0.4.1 → 0.4.2-rc.2

package/build/tools/submitReportTool.js

@@ -1,28 +1,36 @@
 import { z } from "zod";
 import { logger } from "../utils/logger.js";
 import * as fs from "fs/promises";
+import { constants as fsConstants } from "fs";
 import * as path from "path";
 import { AnalyticsService } from "../services/AnalyticsService.js";
 import { SCENARIO_CATEGORIES, categoryExpectsRed, } from "../types/TestRecommendation.js";
-import { TestType } from "../types/TestTypes.js";
-import { STEP_METHOD_DESCRIPTION, stepMethodSchema } from "../types/StepMethod.js";
+import { TESTBOT_SUPPORTED_TEST_TYPES, TestType } from "../types/TestTypes.js";
+import { STEP_METHOD_DESCRIPTION, stepMethodSchema, } from "../types/StepMethod.js";
 import { DriftAction } from "../types/TestAnalysis.js";
 import { TestExecutionStatus } from "../types/TestExecution.js";
 import { IssueFoundCategory } from "../types/TestbotReport.js";
-import { StateManager, runArtifactDir, getTestsRepoDir, resolveRunStatePath, } from "../utils/AnalysisStateManager.js";
+import { StateManager, runArtifactDir, getTestsRepoDir, resolveOwnRunStatePath, } from "../utils/AnalysisStateManager.js";
 import { toolError, testFileMatches } from "../utils/utils.js";
-import { isTestbotEnabled, } from "../utils/featureFlags.js";
-import { answerFor, unknownAnswerObjections } from "../recommendation/answers.js";
-import { checkDeliveredMatchesPlan, checkMaintenanceDelivered } from "../recommendation/verifiers/deliveredMatchesPlan.js";
+import { isTestbotEnabled, isUtilsReuseEnabled, } from "../utils/featureFlags.js";
+import { answerFor, unknownAnswerObjections, } from "../recommendation/answers.js";
+import { checkDeliveredMatchesPlan, checkMaintenanceDelivered, } from "../recommendation/verifiers/deliveredMatchesPlan.js";
 import { checkReportedCategoryMatchesPlan, checkRequirementConflictReported, } from "../recommendation/verifiers/reportedCategory.js";
-import { checkDefectsReported, checkIssueTraceability } from "../recommendation/verifiers/issueTraceability.js";
+import { checkDefectsReported, checkIssueTraceability, } from "../recommendation/verifiers/issueTraceability.js";
 import { checkExpectedOutcomeAfterExecution, } from "../recommendation/verifiers/expectedOutcome.js";
 import { findInvalidSourceCitations, findUnchangedFileClaims, listChangedFiles, listChangedFilesAcross, listChangedFilesAbs, } from "../utils/reportVerification.js";
 import { isPlanOnlyMode } from "../utils/planOnlyMode.js";
+import { contextGaugeSentence } from "../utils/runContextGauge.js";
+import { budgetExcuseRefusals, citesBudget, countBudgetExcuseRefusal, MAX_BUDGET_EXCUSE_REFUSALS, } from "./budgetExcuse.js";
+import { countUiDeliveryRefusal, MAX_UI_DELIVERY_REFUSALS, traceExportAttempts, uiDeliveryRefusals, } from "../playwright/traceExportStore.js";
 import { getReportLanguage, isEnforcedReportLanguage, findLanguageViolations, findLanguageNearMisses, reportLanguageDisplayName, } from "../utils/reportLanguage.js";
 import { canonicalTestPath, findAssertionRecordByFileName, rederiveAssertionOutcome, } from "./code-refactor/assertion-state.js";
-import { rederiveReuse, REUSE_SUBMIT_MAX_REFUSALS, reuseChainSkipped, samePath, } from "./code-refactor/reuse-state.js";
+import { rederiveReuse, deriveReuseFromDelivered, REUSE_SUBMIT_MAX_REFUSALS, reuseChainSkipped, samePath, } from "./code-refactor/reuse-state.js";
 import { retrofitGate, } from "./code-refactor/retrofit-state.js";
+import { onlyCommentLinesRemoved, stripGateMarkers, } from "./code-refactor/gate-markers.js";
+import { parseKeptInline } from "./code-refactor/reuse-outcome.js";
+import { hasUtilsHeader, locateUtilsFiles, parseUtilsAllows, realpath, utilsSpecForFile, } from "../utils/utils-verify/index.js";
+import { verifyTestDependencyChanges } from "../utils/testDependencyPolicy.js";
 // Mirrors the tools wired to planGuard: UI and E2E are not gated at generation
 // time, so gating them here would be a report-time-only surprise.
 const PLAN_GATED_TEST_TYPES = new Set([
@@ -65,7 +73,9 @@ const MAINTENANCE_COVERAGE_ACTIONS = new Set([
  *  an external test's REGENERATE keeps its real action and touches no file, so counting it
  *  would credit a claim nothing backs. */
 function rowsLeavingCoverage(rows) {
-    return (rows ?? []).filter((row) => row?.action !== undefined && MAINTENANCE_COVERAGE_ACTIONS.has(row.action) && row?.reportOnly !== true);
+    return (rows ?? []).filter((row) => row?.action !== undefined &&
+        MAINTENANCE_COVERAGE_ACTIONS.has(row.action) &&
+        row?.reportOnly !== true);
 }
 /** Objection ids for an untested declared change, `coverage:change:<id>`. The
  *  change table reads the agent's answer back off them. */
@@ -74,22 +84,13 @@ const TOOL_NAME = "skyramp_submit_report";
 const DEFAULT_COMMIT_MESSAGE = "Added recommendations by Skyramp Testbot.";
 // Per-repo attribution. In a multi-repo run, every report item carries the
 // owner/repo it pertains to (the primary's owner/repo for primary objections, or a
-// related repo's owner/repo for objections from that repo's diff). Whitespace-only
-// values are normalized to undefined so a blank string is never treated as a
-// distinct repo. Single-repo runs may omit it.
+// related repo's owner/repo for objections from that repo's diff). Trimmed, and
+// a blank string is rejected: every item names its repo, single-repo runs too.
 const repositoryField = z
     .string()
-    .optional()
-    .describe("The 'owner/repo' this item pertains to (e.g. 'letsramp/api-insight'). In a multi-repo run, ALWAYS set it — the primary's owner/repo for primary-repo objections, or a related repo's owner/repo for objections derived from that repository's diff. May be omitted only in single-repo runs.");
-/** Normalize a `repository` attribution: trim, and map a blank/whitespace-only
- *  value to undefined so it is never serialized as a distinct empty repo
- *  (downstream consumers treat absence as "the primary repo"). */
-function normalizeRepository(item) {
-    const trimmed = item.repository?.trim();
-    return trimmed
-        ? { ...item, repository: trimmed }
-        : { ...item, repository: undefined };
-}
+    .trim()
+    .min(1)
+    .describe("The 'owner/repo' this item pertains to (e.g. 'letsramp/api-insight'). Set it on every item — the primary's owner/repo for primary-repo objections, or a related repo's owner/repo for objections derived from that repository's diff.");
 // videoPath is deliberately absent from this input contract: it is attached server-side
 // from the run's execution records (see attachVideoPath), and zod strips any the model
 // supplies anyway. SKYR-4156 is what happens when the agent owns that field instead.
@@ -347,7 +348,7 @@ const issueFoundSchema = z
         .optional()
         .describe("The `id` of the plan defect this issue reports, from the `defects` list you registered with skyramp_register_test_plan. Spell it as that list spells it: an id the plan does not declare traces nothing. " +
         "Set it on the `category: bug` entry that reports the defect. A `defectId` on a `lint`, `type` or `config` entry does not report the defect — the report renders those in its own Configuration Errors section. " +
-        "CHECKED: every plan defect has a `bug` issue that names it, and a `bug` entry with no `plannedTestId` traces through this defect when a delivered test that expects to fail cites it, or when you answered `defects:untested:<id>` at plan time. Leave it out for an issue the plan did not declare."),
+        "CHECKED: every plan defect has a `bug` issue that names it, and a `bug` entry with no `plannedTestId` traces through this defect when a delivered test that expects to fail cites it, when a `maintains` entry you registered cites it, or when you answered `defects:untested:<id>` at plan time. Leave it out for an issue the plan did not declare."),
     sourceFile: citationString.describe("Path of the application file whose code is missing or wrong, relative to the repository root (e.g. 'src/crud/products.py'). " +
         "REQUIRED when category is 'bug'. " +
         "For code that is MISSING — an unmounted router, an unregistered route, an import never added — name the file where the line should be, not the file that defines what is unmounted. " +
@@ -538,6 +539,12 @@ const testMaintenanceSchema = z.object({
         "For failing runs: failure name and one-line root cause, e.g. " +
         "'FAILED test_foo — check_schema fails, order_id=1 has discount from prior PATCH test'. " +
         "Empty string for VERIFY/IGNORE/DELETE entries where no after-execution was run."),
+    /** The ids of the plan defects this maintained test's own run proves. Written
+     *  at report time, not at plan time: by here the test has been executed and the
+     *  agent is recording what it saw, so naming a defect here never displaces the
+     *  planned test that also proves it. A defect may be named by a planned test, by
+     *  a maintenance row, or by both. */
+    defects: z.array(z.string()).default([]),
     // Server-populated from the verdict's own state section, falling back to the
     // run's primary repo. Always set: a consumer that has to treat absence as
     // "probably the primary" cannot tell a single-repo row from a mis-stamped one.
@@ -546,18 +553,28 @@ const testMaintenanceSchema = z.object({
     beforeStatus: z.nativeEnum(TestExecutionStatus),
     afterStatus: z.nativeEnum(TestExecutionStatus),
 });
-// LLM input contract: status fields are server-populated from stateFile.
+// LLM input contract: status fields are server-populated from stateFile, and
+// `defects` is attached from the per-file detail the agent drafts, not from the
+// verdict rows this schema describes.
 const testMaintenanceLLMSchema = testMaintenanceSchema.omit({
     beforeStatus: true,
     afterStatus: true,
+    defects: true,
 });
 // LLM only drafts beforeDetails/afterDetails per file — action/testType/endpoint/description
 // come from stateData.maintenanceVerdicts. Picked from testMaintenanceLLMSchema to avoid
 // redeclaring those fields.
-const testMaintenanceDetailSchema = testMaintenanceLLMSchema.pick({
+const testMaintenanceDetailSchema = testMaintenanceLLMSchema
+    .pick({
     testFilePath: true,
     beforeDetails: true,
     afterDetails: true,
+})
+    .extend({
+    defects: z
+        .array(z.string())
+        .optional()
+        .describe("The ids of the plan defects this test's own run proves, from the `defects` list you registered with skyramp_register_test_plan. Name a defect here when this test failed on it — the failure you summarised in `afterDetails` is the evidence. Spell each id as that list spells it; the report is rejected if an id is not one the plan declares. Naming a defect here does not replace a planned test that proves it: name it here as well."),
 });
 /** The key an answer is matched by: the objection's id AND its message. The id
  *  alone is not unique — one verifier raises several different objections under
@@ -647,45 +664,156 @@ async function attachAssertionOutcome(test, outcomes, checkouts) {
         return test;
     return { ...test, assertions: await rederiveAssertionOutcome(record) };
 }
+/**
+ * The absolute path of a `newTestsCreated` row's delivered file, from the paths the
+ * generators recorded — or the reason it cannot be answered, which the row states.
+ *
+ * A created row carries a `fileName` the agent wrote, which may be a basename or a
+ * repository-relative path, so it cannot be resolved on its own. `generatedTests` is
+ * keyed by canonical absolute path and written by the generators, so the row selects
+ * from it through `testFileMatches` — the segment-aware predicate the delivered-
+ * matches-plan verifier already uses for this question. A row that names a directory
+ * matches only inside it; a bare basename matches on the name alone. Matching by
+ * basename and treating the directory as a tie-breaker let a single same-named file
+ * win against a row whose own path contradicted it, and the row then reported another
+ * file's helpers.
+ *
+ * Both sides are put in posix form first. That predicate reads a path-qualified
+ * candidate by its `/` separators while these keys carry the host's, so on Windows a
+ * uniquely recorded file matched nothing and its row said it could not be found.
+ * Untested: `path.sep` is `/` on the platforms this runs on, so no test on them can
+ * tell the normalization from its absence.
+ *
+ * An unresolved row returns a REASON rather than nothing. Nothing is read by the
+ * caller as "no file to derive from", which ships the ambiguous `reuse: null` this
+ * whole derivation exists to remove — so an ambiguity would have recreated the fault
+ * under a different cause.
+ */
+function generatedPathFor(fileName, generated) {
+    const posix = (p) => p.split(path.sep).join("/");
+    const wanted = posix(fileName);
+    const matches = Object.keys(generated).filter((p) => testFileMatches(posix(p), wanted));
+    if (matches.length === 1)
+        return matches[0];
+    if (matches.length === 0)
+        return {
+            reason: `this run recorded no generated file matching ${fileName}, so its imports could not be read`,
+        };
+    // Several specs of one name in different directories, and a row that names only
+    // the name. Reading the wrong spec's imports is worse than reading none.
+    return {
+        reason: `${matches.length} generated files match ${fileName} and this row does not say which, so its imports could not be read`,
+    };
+}
 async function attachReuseOutcome(test, outcomes, handOffs, retrofits, 
 // A blocking verdict measured on the delivered files is collected here rather
 // than written into the row: the caller refuses the report on it. Required, not
 // defaulted — a caller that forgot it would ship the report with no refusal and
 // no compiler error. See the refusal below the row map.
-blocking) {
+blocking, 
+/** Declines this run removed from the delivered files. See stripDeliveredGateMarkers. */
+carriedDeclines, 
+/** Filled with the carried declines a finding consumed. What consumed nothing is
+ *  retired: permission that covers no fault authorises the NEXT one instead. */
+consumed, 
+/** Filled with the files whose declines this pass actually MEASURED. Only those may
+ *  be retired: a pass that read nothing consumes nothing, and deleting on that
+ *  silence drops permission while the fault it covers is still in the file. */
+evaluated, 
+/** The row's absolute path when the caller has it (a maintenance row does; a
+ *  newTestsCreated row carries a basename only). With it, a record or hand-off
+ *  that names a same-named spec in another directory is not this row's. */
+specPath, 
+/** The delivered file this row is about, absolute — a maintenance row's own path,
+ *  or the path the generators recorded for a newTestsCreated row. Used ONLY for the
+ *  import-derived fallback below, never for record matching, so passing it cannot
+ *  change which record a row attaches.
+ *
+ *  A `{ reason }` says the row HAS a delivered file that could not be identified,
+ *  and the row states that reason. Omitting it altogether says the row has no
+ *  delivered file to read — a VERIFY row, or one this run never wrote. */
+deliveredPath) {
     // POM records describe browser specs; a basename collision with an API test's
     // fileName must not attach them there. A utils-path record is attachable anywhere.
-    const record = outcomes?.[path.basename(test.fileName)];
+    const byBasename = outcomes?.[path.basename(test.fileName)];
+    const record = specPath &&
+        byBasename?.testFilePath &&
+        !samePath(byBasename.testFilePath, specPath)
+        ? undefined
+        : byBasename;
+    if (specPath && handOffs) {
+        handOffs = Object.fromEntries(Object.entries(handOffs).filter(([file]) => samePath(file, specPath)));
+    }
     // A utils record carries the test type its verify ran under: a mismatch is a
     // basename collision with another test, not this row's outcome.
     const typeMatches = !record?.utils?.testType || record.utils.testType === test.testType;
     const found = record && typeMatches && (test.testType === TestType.UI || record.utils)
         ? record
         : undefined;
-    const rederived = found ? await rederiveReuse(found) : undefined;
+    const rederived = found
+        ? await rederiveReuse(found, carriedDeclines)
+        : undefined;
+    consumed.push(...(rederived?.carriedConsumed ?? []));
+    // A measured pass answers for every decline it was handed, including the ones it
+    // found nothing for — that is the answer retirement needs. An unmeasured one
+    // (no record attached here, a missing spec identity, or a verifier that threw)
+    // answers for none of them, and its files stay out of this set.
+    if (rederived?.carriedEvaluated)
+        for (const d of carriedDeclines)
+            if (d.file)
+                evaluated.add(d.file);
     const derived = rederived?.outcome;
     if (rederived?.blocking)
         blocking.push(rederived.blocking);
-    // Pre-existing generated tests this spec's reuse pass rewired (SKYR-4276 A4): the
-    // report names each with its recorded execution, so a reviewer sees that the
-    // module became a dependency of code they already owned — and that it still runs.
-    if (derived?.helpers && found?.testFilePath) {
-        const specPath = found.testFilePath;
-        const mine = retrofits.filter((r) => samePath(r.testFile, specPath));
-        if (mine.length > 0)
-            derived.helpers.retrofits = mine.map((r) => ({
-                file: path.basename(r.file),
-                ...(r.execution ? { execution: r.execution } : {}),
-            }));
-    }
     // The RAW record: a colliding record of any kind means reuse ran for this basename,
-    // and the chain claim must not be made on the filtered view.
-    const chainSkipped = await reuseChainSkipped(test.fileName, test.testType, record, handOffs);
+    // and the chain claim must not be made on the filtered view — pendingReuseChain
+    // fails open on a record it cannot attribute to the spec in front of it, so
+    // claiming the chain was skipped here would put the report and the execute gate
+    // in direct disagreement. The hand-offs ARE the path-filtered view, which is the
+    // same exact-path lookup that gate makes.
+    const chainSkipped = await reuseChainSkipped(test.fileName, test.testType, byBasename, handOffs);
+    // No record and no chain claim leaves the row with `reuse: null`, which reads
+    // identically to "this test reused nothing" — and is read that way. The record is
+    // written by the verify pass, so a row only ever got one when the agent chose to
+    // call `skyramp_reuse_code` with `verify: true` on that file: a field describing
+    // the tool's own activity, presented as a fact about the delivered test. Contract
+    // rows are where it shows, because nothing hands the contract chain a reuse step,
+    // but the delivered file still imports and calls the helpers.
+    //
+    // So answer the row from the file instead. Only where there is nothing else to
+    // report: a row that already carries a record or a chain claim is untouched, and
+    // this can neither overwrite a measured value nor refuse a report.
+    const fallback = !derived && !chainSkipped && deliveredPath && isUtilsReuseEnabled()
+        ? typeof deliveredPath === "string"
+            ? await deriveReuseFromDelivered(deliveredPath)
+            : { notDerived: deliveredPath.reason }
+        : undefined;
     const reuse = derived || chainSkipped
         ? { ...(derived ?? {}), ...(chainSkipped ? { chainSkipped } : {}) }
-        : undefined;
+        : fallback;
     if (!reuse)
         return test;
+    // Pre-existing generated tests this spec's reuse pass rewired (SKYR-4276 A4): the
+    // report names each with its recorded execution, so a reviewer sees that the module
+    // became a dependency of code they already owned — and that it still runs.
+    //
+    // Attached to WHICHEVER helpers outcome reached the row, from the row's own spec
+    // path. Gating it on a stored record instead dropped every retrofit from a row
+    // answered by the fallback — and the retrofit gate still refuses the report until
+    // each one has run, so the run was blocked on a disclosure the report never made.
+    const rowSpecPath = found?.testFilePath ??
+        (typeof deliveredPath === "string" ? deliveredPath : undefined);
+    if (reuse.helpers && rowSpecPath) {
+        const mine = retrofits.filter((r) => samePath(r.testFile, rowSpecPath));
+        if (mine.length > 0)
+            reuse.helpers = {
+                ...reuse.helpers,
+                retrofits: mine.map((r) => ({
+                    file: path.basename(r.file),
+                    ...(r.execution ? { execution: r.execution } : {}),
+                })),
+            };
+    }
     // A record that re-derives to nothing (e.g. a utils path that wrote no file) must
     // not attach an empty object — consumers treat presence as "reuse ran".
     const hasContent = Object.values(reuse).some((v) => v !== undefined);
@@ -708,6 +836,164 @@ function attachVideoPath(row, videos) {
         videoPath: videos?.[path.basename(row.testFilePath)]?.videoPath,
     };
 }
+/**
+ * Remove every comment addressed to a Skyramp gate from the files this run delivers.
+ *
+ * Two gates ask the agent to write a decline INTO the delivered file — the utils
+ * verifier's `reuse-verify: allow` and the POM gate's `// kept inline:` — because a
+ * gate on a later run can only read what the repository holds. The customer ends up
+ * owning both, and a marker records the state at the moment it was written: nothing
+ * re-checks it when the file changes afterwards, so a delivered file can carry a
+ * claim its own code contradicts.
+ *
+ * Called only once the report is WRITTEN, which is the one point that is certainly
+ * the accepted path. A refusal must leave every marker in place: the agent repairs
+ * and resubmits, and a stripped marker would fire the gate again on a fault it has
+ * already declined. Nothing downstream reads a marker — the re-derivation that
+ * builds the report rows has already run, and the action stages current working-tree
+ * content before it commits (`git update-index --again`, plus the test-directory
+ * adds), so an edit made here reaches the commit without any change on that side.
+ *
+ * The accepted cost: a later run re-detects the same fault and the agent declines it
+ * again. That costs turns inside the run and never reaches the customer — and each
+ * run then judges the file in front of it rather than honouring a verdict taken
+ * against an older one.
+ *
+ * Best-effort throughout. The report is already on disk, so nothing here may throw.
+ */
+/**
+ * The delivered files one reuse record owns: the spec itself, and the shared modules
+ * located beside it.
+ *
+ * Only files this RUN changed. `locateUtilsFiles` also returns a module the spec
+ * merely imports, and a marker an older run left in one of those is not this run's to
+ * remove — editing it would put a file the run never touched into the customer's pull
+ * request. When the change list cannot be read the located set is used unchanged,
+ * which is the behaviour every other reuse check falls back to.
+ */
+export async function deliveredFilesOf(record, changed) {
+    const testFile = record.testFilePath;
+    if (!testFile)
+        return [];
+    // Both sides of the comparison are canonicalised HERE, because this function owns
+    // the comparison. `listChangedFilesAbs` resolves its paths and the located files are
+    // real paths, so on a repository whose path traverses a symlink the two spellings
+    // never matched and nothing was stripped — silently, and only on those setups.
+    const changedReal = changed
+        ? new Set(await Promise.all([...changed].map(realpath)))
+        : undefined;
+    // The spec takes the same membership check as the modules beside it. Exempting it
+    // let the strip edit a spec this run never touched — the same fault as an
+    // imported-only module, and the same new diff in the customer's pull request.
+    const spec = await realpath(testFile);
+    const files = !changedReal || changedReal.has(spec) ? [spec] : [];
+    try {
+        for (const utilsFile of await locateUtilsFiles({
+            testFile,
+            language: record.language,
+        })) {
+            const real = await realpath(utilsFile);
+            if (!changedReal || changedReal.has(real))
+                files.push(real);
+        }
+    }
+    catch (err) {
+        logger.warning("Could not locate the shared utils files for a delivered spec", { testFile, error: String(err) });
+    }
+    return files;
+}
+async function stripDeliveredGateMarkers(outcomes, retrofits, 
+/** Absolute paths this run changed, or undefined when they cannot be read. */
+changed) {
+    const stripped = {};
+    const files = new Set();
+    // Each grammar has ONE file role its gate reads it from: `verifyUtils` reads
+    // `reuse-verify: allow` out of a located utils module, and the re-derivation reads
+    // `// kept inline:` out of the record's spec. Parsing both out of every file made a
+    // marker in the wrong place MORE powerful than the gate treats it: an allow the
+    // agent wrote into the spec is ignored where it sits, but was recorded here and
+    // then authorised the next matching helper fault. The strip still removes it —
+    // nothing addressed to the gate ships — it is only not carried.
+    const specPaths = new Set(await Promise.all(Object.values(outcomes ?? {})
+        .map((r) => r?.testFilePath)
+        .filter((p) => !!p)
+        .map(realpath)));
+    // Every path is canonicalised here and in the record, for the reason `reuseHandOffs`
+    // keys on `realpath`: a tool-supplied path may reach the same file through a symlink
+    // (macOS resolves /tmp to /private/tmp), so a raw key written by one source and read
+    // from another names one file twice.
+    // Every file this run CHANGED, when the change list can be read. Recording a reuse
+    // outcome is best-effort, so a changed file with no record would never be scanned —
+    // and its marker would ship, against what AC5 and this tool's description promise.
+    // The records are the fallback for when the change list is not available.
+    // Canonicalised on the way in, like every other source. `listChangedFilesAbs` only
+    // RESOLVES its names, against the root git was given, so a checkout reached through
+    // a symlink keeps that spelling — and the record would name a file the next
+    // submission looks up by real path, losing the decline it just carried.
+    if (changed)
+        for (const file of changed)
+            files.add(await realpath(file));
+    else
+        for (const record of Object.values(outcomes ?? {}))
+            for (const file of await deliveredFilesOf(record ?? {}, undefined))
+                files.add(file);
+    // Pre-existing generated tests this run rewired: the delivery commits them too.
+    for (const retrofit of retrofits)
+        files.add(await realpath(retrofit.file));
+    for (const file of files) {
+        const spec = utilsSpecForFile(file);
+        if (!spec)
+            continue;
+        try {
+            const before = await fs.readFile(file, "utf-8");
+            const { content, removed, unremovable } = stripGateMarkers(before, spec);
+            if (unremovable.length > 0) {
+                logger.warning("A gate-addressed comment could not be removed from a delivered file without risking its syntax — it ships as it stands", { file, markers: unremovable });
+            }
+            if (removed.length === 0)
+                continue;
+            // The last check before the customer's file changes, and the only one that does
+            // not depend on the strip being right. Every defect this had was a case nobody
+            // foresaw; this states the one edit that is permitted and refuses the rest, so
+            // an unforeseen case delivers the marker instead of a file that does not build.
+            if (!onlyCommentLinesRemoved(before, content, spec.commentPrefix)) {
+                logger.warning("The gate-comment strip would have changed more than whole comment lines — the file is left exactly as delivered", { file, removed });
+                continue;
+            }
+            await fs.writeFile(file, content, "utf-8");
+            // Parsed, not kept as text: what a later call needs is WHICH decline was made,
+            // so it can read it the way it reads a marker still in the file. Keeping the
+            // line and appending it back edited the customer's file a second time, and an
+            // agent that reformatted or reworded the decline in between defeated the
+            // substring match in both directions.
+            const text = removed.join("\n");
+            const declines = [
+                ...((await hasUtilsHeader(file))
+                    ? parseUtilsAllows(text, spec).allows.map(({ kind, helper }) => ({
+                        kind,
+                        helper,
+                    }))
+                    : []),
+                ...(specPaths.has(file)
+                    ? parseKeptInline(text).map(({ pageObject, reason }) => ({
+                        keptInline: pageObject,
+                        reason,
+                    }))
+                    : []),
+            ];
+            if (declines.length > 0)
+                stripped[file] = declines;
+            logger.info("Removed gate-addressed comment(s) from a delivered file", {
+                file,
+                removed,
+            });
+        }
+        catch (err) {
+            logger.warning("Could not strip gate-addressed comments from a delivered file", { file, error: String(err) });
+        }
+    }
+    return stripped;
+}
 /** Two-space indent on every line, so a multi-line verdict reads as one bullet's body. */
 function indent(text) {
     return text
@@ -740,20 +1026,13 @@ function deduplicateById(items) {
  *  basename. A file can own several rows: failed if ANY failed, first failure
  *  carries the text; `Skipped` rows are evidence in neither direction. */
 function collectExecutionOutcomes(delivered, results) {
-    // Absent names nothing to disagree with, so it matches any — the same rule
-    // `checkEveryDeliveredTestRan` uses.
-    const sameRepository = (a, b) => {
-        const left = (a ?? "").trim();
-        const right = (b ?? "").trim();
-        return left === "" || right === "" || left === right;
-    };
     const outcomes = [];
     for (const test of delivered) {
         const plannedTestId = test.plannedTestId?.trim();
         if (!plannedTestId)
             continue;
         const rows = results.filter((row) => row.status !== "Skipped" &&
-            sameRepository(row.repository, test.repository) &&
+            row.repository === test.repository &&
             testFileMatches(row.testFilePath, test.fileName));
         if (rows.length === 0)
             continue;
@@ -819,23 +1098,15 @@ function checkOneEntryPerCandidate(delivered) {
  *  a planned test with no outcome, so a filename the results do not carry was the
  *  way past it. This is the check that says so. */
 function checkEveryDeliveredTestRan(delivered, results) {
-    // A side that names no repository names none to disagree with, so it matches
-    // any. A single-repo run fills the field on one list and not the other often
-    // enough that requiring both to agree reported tests that had plainly run.
-    const sameRepository = (a, b) => {
-        const left = (a ?? "").trim();
-        const right = (b ?? "").trim();
-        return left === "" || right === "" || left === right;
-    };
     return delivered
-        .filter((test) => !results.some((row) => sameRepository(row.repository, test.repository) &&
+        .filter((test) => !results.some((row) => row.repository === test.repository &&
         testFileMatches(row.testFilePath, test.fileName)))
         .map((test) => {
         // Say which half failed. "No row names that file" reads as a missing run
         // when the file is there and only the repository differs.
         const byName = results.filter((row) => testFileMatches(row.testFilePath, test.fileName));
         const evidence = byName.length
-            ? `reported as ${test.fileName} for ${test.repository?.trim() || "no repository"}, and the ${byName.length === 1 ? "row" : "rows"} naming that file ${byName.length === 1 ? "is" : "are"} for ${byName.map((row) => row.repository?.trim() || "no repository").join(", ")}`
+            ? `reported as ${test.fileName} for ${test.repository}, and the ${byName.length === 1 ? "row" : "rows"} naming that file ${byName.length === 1 ? "is" : "are"} for ${byName.map((row) => row.repository).join(", ")}`
             : `reported as ${test.fileName}, no testResults row names that file`;
         return {
             objectionId: `deliveredTestRan:${test.testId}`,
@@ -846,15 +1117,118 @@ function checkEveryDeliveredTestRan(delivered, results) {
         };
     });
 }
-/** The four types a plan can express. `registerTestPlanTool`'s `PLAN_TEST_TYPES`
- *  is the same list; the report accepts every `TestType`, so an entry outside
- *  these four can never name a plan planned test and must not be asked to. */
-const PLANNABLE_TEST_TYPES = new Set([
-    TestType.CONTRACT,
-    TestType.INTEGRATION,
-    TestType.E2E,
-    TestType.UI,
-]);
+/** A report cannot treat an explicit skip as a completed execution. Unlike an absent
+ *  result, this is a direct claim that the agent chose not to run a delivered test. */
+function skippedDeliveredTests(delivered, results) {
+    return delivered.filter((test) => {
+        const matching = results.filter((row) => row.repository === test.repository &&
+            testFileMatches(row.testFilePath, test.fileName));
+        return (matching.some((row) => row.status === "Skipped") &&
+            !matching.some((row) => row.status !== "Skipped"));
+    });
+}
+/** A planned test the plan typed `ui`. The plan's `testType` is free-form text —
+ *  the unapproved-entry check above says so — so it is trimmed and lower-cased
+ *  rather than compared against the enum. */
+function plannedUiTests(plannedTests) {
+    return plannedTests.filter((test) => !!test?.plannedTestId?.trim() &&
+        String(test?.scenario?.testType ?? "")
+            .trim()
+            .toLowerCase() === TestType.UI);
+}
+/** Planned UI tests with no entry in the report: the recordings that never
+ *  happened, named by the ids the agent would otherwise only have to answer for. */
+/** Every planned test with no entry in the report, whatever its type. The UI
+ *  filter below narrows this; the budget-excuse gate does not, because a dropped
+ *  contract test is dropped the same way a dropped recording is. */
+function undeliveredPlannedTests(plannedTests, delivered) {
+    const shipped = new Set(delivered
+        .map((test) => test.plannedTestId?.trim())
+        .filter((id) => !!id));
+    return plannedTests.filter((test) => !!test?.plannedTestId?.trim() && !shipped.has(test.plannedTestId.trim()));
+}
+function undeliveredPlannedUiTests(plannedTests, delivered) {
+    return undeliveredPlannedTests(plannedUiTests(plannedTests), delivered);
+}
+/** Whether the file can be read. The written record outlives the file, and a
+ *  path that exists but cannot be opened owes no run either — the objection
+ *  would name a file nobody can look at. */
+async function pathExists(file) {
+    try {
+        await fs.access(file, fsConstants.R_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Whether the recorded run is a run of what this run WROTE.
+ *
+ *  An edited file is run twice — once before the edit for a baseline, once
+ *  after — and only the second says anything about the edit, so a file left with
+ *  just its baseline has not been run in the sense this check is about.
+ *
+ *  A generated file has no baseline of its own, but the path may still carry an
+ *  older run: REGENERATE rewrites a file that already existed and was already
+ *  run, and generating twice to one path does the same. The run has to be later
+ *  than the write, or it is a run of bytes that are gone. An unreadable or
+ *  missing timestamp on either side falls back to "a run is a run", which is the
+ *  behaviour before this and never invents an objection. */
+function runOfWhatWasWritten(file) {
+    if (file.how === "updated")
+        return file.recordedPhase === "after";
+    if (file.recordedPhase === undefined)
+        return false;
+    const wrote = file.generatedAt;
+    // The execution record keeps an ISO string, written by the execution path
+    // rather than here, so it is parsed rather than changed in this PR.
+    const ran = Date.parse(file.executedAt ?? "");
+    if (wrote === undefined || Number.isNaN(ran))
+        return true;
+    return ran >= wrote;
+}
+/** Every test file this run wrote has an execution this server performed.
+ *
+ *  Informational, like every check here: it surfaces the gap for a person to read
+ *  and the agent can answer it. The agent is not blocked — a hard ban on running a
+ *  test outside the tool can dead-end a run, which is why the prompt states a
+ *  preference rather than a rule.
+ *
+ *  The two lists it joins are both the server's own, keyed by canonical absolute
+ *  path: `generatedTests`, written by the generators, and `testExecutions`,
+ *  written by skyramp_execute_test. The agent supplies neither, so unlike the
+ *  report-side checks this cannot be satisfied by what the report claims.
+ *
+ *  What it proves is that the file was handed to the runner. It is NOT proof that
+ *  a test ran: a runner can exit 0 having executed nothing. */
+function checkEveryWrittenTestRan(written) {
+    return written
+        .filter((file) => !runOfWhatWasWritten(file))
+        .map((file) => ({
+        // The path is the id, because the agent quotes the id back in `answers` and a
+        // path is what it can recognise. Everything after the first colon is that
+        // path, colons included — a reader must not split the id on every colon.
+        objectionId: `testRanOnThisServer:${file.file}`,
+        verifier: "testRanOnThisServer",
+        // Says what is recorded, never that the file went unrun: the agent is
+        // allowed to run a test with the repository's own runner, and a run it
+        // drove itself is not visible here.
+        message: file.how === "generated"
+            ? "This run generated this test file, and this server recorded no run of it after it was written."
+            : file.recordedPhase === "before"
+                ? "This run edited this test file, and the only run of it this server recorded is from before the edit."
+                : "This run edited this test file, and this server recorded no run of it.",
+        evidence: file.recordedPhase === "before"
+            ? `${file.file} — the only recorded skyramp_execute_test run of this file is the pre-edit baseline`
+            : file.how === "generated" && file.recordedPhase !== undefined
+                ? `${file.file} — the last recorded skyramp_execute_test run of this path is older than the file this run wrote`
+                : `${file.file} — no skyramp_execute_test run of this file is recorded`,
+        suggestion: "Either run the file with `skyramp_execute_test`, or answer this objection in `answers` — say how the test was run, or why it was not run. A `testResults` row does not answer this: the run is checked against the executions this server performed, not against what the report claims.",
+    }));
+}
+/** The report accepts every `TestType`, so an entry outside the four a plan can
+ *  express can never name a planned test and must not be asked to. */
+const PLANNABLE_TEST_TYPES = new Set(TESTBOT_SUPPORTED_TEST_TYPES);
 function runPostExecutionChecks(plan, delivered, results, issues, 
 /** The plan-only lane delivers nothing, so there a planned test is proof
  *  enough for a bug. Passed in, not read here, so the checks stay pure. */
@@ -864,9 +1238,12 @@ planOnly, maintained = []) {
         // unplanned: a plan cannot hold one, so the objection would name a mistake the
         // agent has no way to fix.
         .filter((test) => PLANNABLE_TEST_TYPES.has(test.testType))
-        .map((test) => test.plannedTestId?.trim())
-        .filter((id) => !!id)
-        .map((plannedTestId) => ({ plannedTestId }));
+        .flatMap((test) => {
+        const plannedTestId = test.plannedTestId?.trim();
+        return plannedTestId
+            ? [{ plannedTestId, repository: test.repository }]
+            : [];
+    });
     return [
         ...runPostExecutionCheck("deliveredMatchesPlan", "deliveredMatchesPlan", () => checkDeliveredMatchesPlan(plan, shipped)),
         // The maintenance mirror: a `maintains` entry credited coverage at plan time,
@@ -881,17 +1258,37 @@ planOnly, maintained = []) {
         ...runPostExecutionCheck("defectsReported", "defects:unreported", () => checkDefectsReported(plan, issues)),
     ];
 }
+/**
+ * Dependency edits can land in the primary checkout, a separate tests checkout,
+ * or a related repository. Verify each configured path once, skipping absent paths.
+ */
+function collectDependencyVerificationRoots(primaryRepoRoot, testsRepoRoot, relatedRepos) {
+    const roots = new Set([primaryRepoRoot]);
+    if (testsRepoRoot) {
+        roots.add(testsRepoRoot);
+    }
+    for (const repo of Object.values(relatedRepos ?? {})) {
+        if (repo.repositoryPath) {
+            roots.add(repo.repositoryPath);
+        }
+    }
+    return Array.from(roots);
+}
 export function registerSubmitReportTool(server) {
     server.registerTool(TOOL_NAME, {
         annotations: {
             readOnlyHint: false,
-            destructiveHint: true, // overwrites the report file on disk
+            // Overwrites the report file on disk, AND edits delivered source files on an
+            // accepted call: a comment addressed to a Skyramp gate is removed from each
+            // file this run changed. See stripDeliveredGateMarkers.
+            destructiveHint: true,
             idempotentHint: false,
             openWorldHint: false,
         },
         description: "Submit the final testbot report. Call this tool once, after all test analysis, generation and execution. " +
             "This is the ONLY way to submit the report — do NOT write the report to a file manually. " +
-            "If a check objects to what you reported, the objection names an id: fix what you can, and answer the rest through `answers` on a second call.",
+            "If a check objects to what you reported, the objection names an id: fix what you can, and answer the rest through `answers` on a second call. " +
+            "On an ACCEPTED call this tool also edits the files this run changed: a comment addressed to a Skyramp gate — `reuse-verify: allow …` or `// kept inline: …` — is removed from each of them, because it speaks to a gate and not to the customer who owns the file. Nothing else in those files is touched. A REFUSED call leaves every source file exactly as it found it; it still records its own run state, such as the refusal count and the objections it raised.",
         inputSchema: {
             businessCaseAnalysis: z
                 .string()
@@ -951,8 +1348,9 @@ export function registerSubmitReportTool(server) {
             stateFile: z
                 .string()
                 .optional()
-                .describe("Optional. A Testbot run finds its own state file, so leave this out. " +
-                "Give a path only to name a state file the run would not find by itself. " +
+                .describe("Optional, and a Testbot run leaves it out: the run finds its own state file. " +
+                "A path is accepted only when it names that same file — one from another run holds " +
+                "another run's execution results, and the call is refused. " +
                 "The report is written beside it, and it holds the execution results, the " +
                 "page captures and the videos this report needs."),
         },
@@ -967,7 +1365,9 @@ export function registerSubmitReportTool(server) {
         // event in the finally. Empty (no properties) for non-enforced runs.
         const languageTelemetry = {};
         // The run's own state file, unless the agent named one.
-        const stateFile = resolveRunStatePath(params.stateFile);
+        const { path: stateFile, refusal } = resolveOwnRunStatePath(params.stateFile);
+        if (refusal)
+            return toolError(refusal);
         if (!stateFile) {
             return toolError("This run has no state file. Call skyramp_analyze_changes first — it writes the state file this report goes beside.");
         }
@@ -1145,8 +1545,7 @@ export function registerSubmitReportTool(server) {
                 const plannedTest = plannedById.get((t.plannedTestId ?? "").trim());
                 if (!plannedTest)
                     return true;
-                const plannedType = String(plannedTest.scenario?.testType ?? "").trim().toLowerCase();
-                return plannedType !== "" && plannedType !== t.testType;
+                return plannedTest.scenario.testType !== t.testType;
             });
             if (unapproved.length > 0) {
                 const plannedList = plannedById.size > 0
@@ -1168,13 +1567,10 @@ export function registerSubmitReportTool(server) {
         // Read once — the file can carry a large diffText and readRepoData would
         // re-parse it twice per repo.
         const fullMaintenanceState = await stateManager.readFullState();
-        // The state file's root names the primary only when a caller declared one
-        // (or wrote first). GITHUB_REPOSITORY is the trigger event's own repo, so
-        // it names the primary even for a run that passed neither repo argument.
-        const primaryRepository = fullMaintenanceState?.metadata?.repository?.trim() ||
-            process.env.GITHUB_REPOSITORY?.trim() ||
-            undefined;
-        const maintenanceSections = [{ data: stateData }];
+        // The handler already refused above when the file was missing or empty,
+        // and the run that created it names the primary on the root.
+        const primaryRepository = fullMaintenanceState.metadata.repository;
+        const maintenanceSections = [{ repository: primaryRepository, data: stateData }];
         for (const [repo, section] of Object.entries(fullMaintenanceState?.relatedRepos ?? {})) {
             // Only these two keys resolve back to the primary, already collected
             // above. Any other key — a case variant, or another name over the same
@@ -1189,27 +1585,16 @@ export function registerSubmitReportTool(server) {
                 maintenanceSections.push({ repository: repo, data });
         }
         // Stamp every row, primary included and single-repo runs included — as the
-        // prompt already requires of the other report sections. A section without
-        // its own name is the primary's, so it takes the run's primary repo.
-        const repositoryOf = (section) => section.repository ?? primaryRepository ?? "";
-        // Required field, so refuse rather than stamp a blank one: nothing named
-        // the primary and the run is not on a GitHub runner either. Only sections
-        // that actually produce rows need a name — a run with no verdicts at all
-        // has nothing to attribute and must still be able to submit.
-        if (!primaryRepository &&
-            maintenanceSections.some((section) => !section.repository &&
-                (section.data.maintenanceVerdicts?.length ?? 0) > 0)) {
-            errorResult = toolError("Cannot name the repository for the maintenance rows: the stateFile records no primary repository " +
-                "and GITHUB_REPOSITORY is unset. Pass `repository` (and `primaryRepository` in a multi-repo run) " +
-                "to skyramp_analyze_changes, then re-run it.");
-            return errorResult;
-        }
+        // prompt already requires of the other report sections. The primary's
+        // section carries the name the state file's root records; a related repo's
+        // carries its own section key.
+        const repositoryOf = (section) => section.repository;
         // Reject rather than throw: a non-array here, or a missing testFilePath
         // below, escapes the handler and loses the analytics event in its `finally`.
         const malformedSections = maintenanceSections
             .filter(({ data }) => data.maintenanceVerdicts !== undefined &&
             !Array.isArray(data.maintenanceVerdicts))
-            .map(({ repository }) => repository ?? "the primary repo");
+            .map(({ repository }) => repository);
         if (malformedSections.length > 0) {
             errorResult = toolError(`stateFile has a non-array maintenanceVerdicts for: ${malformedSections.join(", ")}. ` +
                 `Re-run skyramp_actions for that repository to rewrite the section.`);
@@ -1225,9 +1610,11 @@ export function registerSubmitReportTool(server) {
         // verdict PER page object, so a spec-keyed map keeps only the last.
         const rawMaintenance = maintenanceSections.flatMap((section) => (section.data.maintenanceVerdicts ?? [])
             .filter((v) => {
-            if (v && typeof v.testFilePath === "string" && v.testFilePath.trim())
+            if (v &&
+                typeof v.testFilePath === "string" &&
+                v.testFilePath.trim())
                 return true;
-            badVerdicts.push(section.repository ?? "the primary repo");
+            badVerdicts.push(section.repository);
             return false;
         })
             .map((v) => ({
@@ -1237,6 +1624,7 @@ export function registerSubmitReportTool(server) {
             testType: v.testType,
             endpoint: v.endpoint,
             action: v.action,
+            reportOnly: v.reportOnly,
             // A baseline refresh (SKYR-4298) leaves the spec untouched, so name the
             // replaced PNGs here — the reviewer's cue to open the image diff in the PR.
             description: v.rebaselineSnapshots?.length
@@ -1273,6 +1661,12 @@ export function registerSubmitReportTool(server) {
         // draft a summary for it) — collected here and rejected below, rather than
         // silently shipping a blank field.
         const missingDetails = [];
+        // An id no plan defect declares traces nothing, exactly as `defectId` on an
+        // issue does not: without this the row could name a defect the run invented.
+        const declaredDefectIds = new Set((stateData.plan?.defects ?? [])
+            .map((d) => String(d?.id ?? "").trim())
+            .filter((id) => id.length > 0));
+        const undeclaredDefects = [];
         if (dedupedMaintenance.length > 0) {
             // beforeStatus/afterStatus are always stateFile-authoritative. beforeDetails/
             // afterDetails come from the LLM's drafted summary (testMaintenanceDetails) —
@@ -1299,20 +1693,39 @@ export function registerSubmitReportTool(server) {
                 // must not satisfy the "drafted a summary" requirement.
                 const beforeDetails = detail?.beforeDetails?.trim() ?? "";
                 const afterDetails = detail?.afterDetails?.trim() ?? "";
-                if (recorded?.executionBefore && !beforeDetails)
+                // A recorded run owes a summary. The Unknown placeholder a reservation
+                // leaves when the run never landed a result (SKYR-4460) is not one:
+                // there is no output to summarise, and the row publishes Unknown.
+                const recordedBefore = recorded?.executionBefore &&
+                    recorded.executionBefore.status !== TestExecutionStatus.Unknown;
+                const recordedAfter = recorded?.executionAfter &&
+                    recorded.executionAfter.status !== TestExecutionStatus.Unknown;
+                if (recordedBefore && !beforeDetails)
                     missingDetails.push(`${displayName} (beforeDetails)`);
-                if (recorded?.executionAfter && !afterDetails)
+                if (recordedAfter && !afterDetails)
                     missingDetails.push(`${displayName} (afterDetails)`);
                 logger.info(`${displayName}: before=${beforeStatus} after=${afterStatus}`);
+                const defects = (detail?.defects ?? [])
+                    .map((id) => String(id ?? "").trim())
+                    .filter((id) => id.length > 0);
+                for (const id of defects)
+                    if (!declaredDefectIds.has(id))
+                        undeclaredDefects.push(`${displayName}: ${id}`);
                 return {
                     ...m,
                     beforeDetails,
                     afterDetails,
+                    defects,
                     beforeStatus,
                     afterStatus,
                 };
             });
         }
+        if (undeclaredDefects.length > 0) {
+            errorResult = toolError(`${undeclaredDefects.length} maintenance row(s) name a defect the plan does not declare: ${undeclaredDefects.join(", ")}. ` +
+                "Spell each id as your registered `defects` list spells it, or leave it out.");
+            return errorResult;
+        }
         if (missingDetails.length > 0) {
             const uniqueMissing = [...new Set(missingDetails)];
             errorResult = toolError(`${uniqueMissing.length} maintenance row(s) have a recorded execution but no drafted summary: ${uniqueMissing.join(", ")}. ` +
@@ -1324,6 +1737,9 @@ export function registerSubmitReportTool(server) {
         // rows below; an unexecuted one refuses the report (inside the SKYR-3883 block,
         // which already enumerates the working tree).
         let retrofitViews = [];
+        /** Absolute paths this run changed. Undefined when they cannot be read — every
+         *  reuse check falls back to acting on what it located. */
+        let changedFilesAbs;
         // SKYR-3883: in a testbot run, refuse to ship a report that claims file work
         // the working tree doesn't reflect. The delivery step can only commit what the
         // agent actually created/edited, so a report claiming otherwise erodes trust
@@ -1335,6 +1751,25 @@ export function registerSubmitReportTool(server) {
             const fullState = await stateManager.readFullState();
             const repoRoot = fullState?.metadata?.repositoryPath;
             if (repoRoot && repoRoot !== "unknown") {
+                const dependencyRoots = collectDependencyVerificationRoots(repoRoot, getTestsRepoDir(), fullState?.relatedRepos);
+                for (const dependencyRoot of dependencyRoots) {
+                    try {
+                        const dependencyVerification = await verifyTestDependencyChanges(dependencyRoot);
+                        if (!dependencyVerification.ok) {
+                            errorResult = toolError("The working tree violates the safe test-only dependency policy:\n" +
+                                dependencyVerification.violations
+                                    .map((violation) => `  - ${violation}`)
+                                    .join("\n") +
+                                "\nMove approved packages to the required development/test scope, remove unapproved or unrelated manifest edits, run skyramp_verify_test_dependencies, and submit the report again.");
+                            return errorResult;
+                        }
+                    }
+                    catch (err) {
+                        errorResult = toolError(`Could not verify test dependency changes in ${dependencyRoot}: ${err.message}. ` +
+                            "Testbot will not submit the report until every configured repository can be checked.");
+                        return errorResult;
+                    }
+                }
                 try {
                     // A run writes tests into up to three kinds of trees: the primary
                     // checkout, the tests-repo checkout (testRepoPath), and related
@@ -1363,7 +1798,11 @@ export function registerSubmitReportTool(server) {
                         changedFiles,
                         newTests: dedupedNewTests,
                         verdicts: stateData.maintenanceVerdicts ?? [],
-                        primaryRepository: fullState?.metadata?.repository,
+                        primaryRepository,
+                        knownRepositories: [
+                            primaryRepository,
+                            ...Object.keys(fullState?.relatedRepos ?? {}),
+                        ],
                         // SKYR-4250: captured at prompt-render time, since planOnly is a
                         // prompt-only argument (mirrors the SKYR-4185 language capture).
                         planOnly: isPlanOnlyMode(),
@@ -1392,7 +1831,7 @@ export function registerSubmitReportTool(server) {
                             `Files with actual working-tree changes:\n${changedList || "  (none)"}`);
                         return errorResult;
                     }
-                    const changedFilesAbs = await listChangedFilesAbs([
+                    changedFilesAbs = await listChangedFilesAbs([
                         repoRoot,
                         getTestsRepoDir(),
                         ...Object.values(fullState?.relatedRepos ?? {}).map((section) => section.repositoryPath),
@@ -1417,7 +1856,7 @@ export function registerSubmitReportTool(server) {
         // `repository` is normalized BEFORE the check so the attribution the check
         // reconciles is the one the report ships, and so the stamp below survives
         // into the written file — this array is what the report is built from.
-        const issuesFound = params.issuesFound.map(normalizeRepository);
+        const issuesFound = params.issuesFound;
         if (issuesFound.some((issue) => issue.sourceFile?.trim())) {
             const citations = await findInvalidSourceCitations({
                 checkouts: await stateManager.listRepoCheckouts(),
@@ -1446,11 +1885,134 @@ export function registerSubmitReportTool(server) {
         const assertionCheckouts = await stateManager
             .listRepoCheckouts()
             .catch(() => []);
+        // Declines an earlier accepted submission removed from the delivered files.
+        // They are handed to the re-derivation rather than written back into the files:
+        // the run still knows what it declined, and the customer's copy is edited once.
+        //
+        // Keyed by the SPEC that owns the file the decline came from. Handing every
+        // row every decline let one about one spec's helper clear a live finding in
+        // another spec that defines a helper of the same name.
+        const changedSet = changedFilesAbs ? new Set(changedFilesAbs) : undefined;
+        const declinesBySpec = new Map();
+        /** Files whose declines some record can still reach. One no record owns can
+         *  never be consumed by anything, so it is retired without a measurement; one
+         *  that IS owned is retired only on a measurement that found no fault. */
+        const reachableDeclineFiles = new Set();
+        for (const [name, record] of Object.entries(stateData.reuseOutcomes ?? {})) {
+            const mine = [];
+            // Every file the record owns, NOT only the ones this run changed. The filter
+            // decides what the strip may EDIT; a decline already recorded against a file
+            // is this run's whatever the working tree says, and dropping it makes the
+            // gate refuse a fault the run already declined.
+            for (const file of await deliveredFilesOf(record ?? {}, undefined)) {
+                if ((stateData.strippedDeclines?.[file] ?? []).length > 0)
+                    reachableDeclineFiles.add(file);
+                mine.push(...(stateData.strippedDeclines?.[file] ?? []).map(
+                // Tagged with where it was read from, so a consumption retires THAT
+                // file's record and not an identical one stored for another spec.
+                (d) => ({ ...d, file })));
+            }
+            if (mine.length > 0)
+                declinesBySpec.set(name, mine);
+        }
         const reuseBlocking = [];
+        /** Carried declines a finding consumed on this call. */
+        const consumedDeclines = [];
+        /** Files whose stored declines a re-derivation actually measured on this call. */
+        const evaluatedDeclineFiles = new Set();
         const sanitizedNewTests = await Promise.all(dedupedNewTests.map(async ({ scenarioFile: _sf, traceFile: _tf, frontendTrace: _ft, ...rest }) => {
-            const row = await attachReuseOutcome(normalizeRepository(rest), stateData.reuseOutcomes, stateData.reuseHandOffs, retrofitViews, reuseBlocking);
+            const row = await attachReuseOutcome(rest, stateData.reuseOutcomes, stateData.reuseHandOffs, retrofitViews, reuseBlocking, declinesBySpec.get(path.basename(rest.fileName)) ?? [], consumedDeclines, evaluatedDeclineFiles, undefined, generatedPathFor(rest.fileName, stateData.generatedTests ?? {}));
             return attachAssertionOutcome(row, stateData.assertionOutcomes ?? {}, assertionCheckouts);
         }));
+        const maintenanceRows = testMaintenance
+            ? await Promise.all(testMaintenance.map(async ({ testFilePath, pomFile, reportOnly, ...row }) => {
+                // `pomFile` is the file skyramp_actions told the agent to edit;
+                // `testFilePath` stays the spec, which is what ran. Name both when
+                // they differ, or a page-object edit is reported against the spec.
+                // Maintenance rows still carry the absolute path here, so the
+                // assertion summary uses an EXACT canonical-path lookup — no
+                // basename ambiguity. This is what carries the maintenance
+                // honesty labels (nothing-to-verify vs verified) into the
+                // report instead of leaving them as tool text the agent can
+                // paraphrase.
+                const record = stateData.assertionOutcomes?.[canonicalTestPath(testFilePath)];
+                const assertions = record
+                    ? await rederiveAssertionOutcome(record)
+                    : undefined;
+                // A maintained test goes through modularize → reuse like a
+                // generated one, so its row carries the same server-derived
+                // reuse outcome, matched by its exact path. Wraps the
+                // repository-attributed row, the same composition
+                // newTestsCreated uses.
+                return attachReuseOutcome({
+                    ...row,
+                    fileName: path.basename(testFilePath),
+                    ...(pomFile &&
+                        path.basename(pomFile) !== path.basename(testFilePath)
+                        ? { editedFileName: path.basename(pomFile) }
+                        : {}),
+                    ...(assertions ? { assertions } : {}),
+                }, stateData.reuseOutcomes, stateData.reuseHandOffs, retrofitViews, reuseBlocking, declinesBySpec.get(path.basename(testFilePath)) ?? [], consumedDeclines, evaluatedDeclineFiles, testFilePath, 
+                // Only where the run edited the file and left a test standing.
+                // VERIFY and IGNORE read a repository-owned test and changed nothing,
+                // and DELETE removed it — none of the three has reuse to state, so a
+                // sentence about what they import is noise on a complete row. A
+                // report-only row keeps a real REGENERATE or DELETE while this run
+                // touched nothing, so the action alone does not answer it; the same
+                // pair of conditions `rowsLeavingCoverage` applies.
+                MAINTENANCE_COVERAGE_ACTIONS.has(row.action) &&
+                    reportOnly !== true
+                    ? testFilePath
+                    : undefined);
+            }))
+            : undefined;
+        // Retirement happens HERE: after BOTH row kinds have re-derived, and still
+        // before any refusal can return. Running it between them left a decline owned
+        // only by a maintained spec unmeasured at this point — retired on that silence
+        // before the fix below, and then kept forever once silence stopped retiring. A decline whose fault
+        // the agent repaired has nothing left to authorise, and a submission that is
+        // then refused for an UNRELATED fault used to leave it in place — so while
+        // repairing that one the agent could reintroduce the first and the next
+        // submission would authorise it in silence. Only the physical strip has to wait
+        // for the accepted path; the record does not.
+        //
+        // Reconciled whenever any decline is stored, not when a count says it changed:
+        // `consumedDeclines` accumulates per report ROW, so two rows consuming one
+        // decline made the totals match while a second, stale decline survived.
+        if (Object.keys(stateData.strippedDeclines ?? {}).length > 0) {
+            const budget = [...consumedDeclines];
+            const kept = Object.fromEntries(Object.entries(stateData.strippedDeclines ?? {}).map(([file, stored]) => [
+                file,
+                // Retire on an ANSWER, not on a silence. A file a record still owns,
+                // whose re-derivation did not measure it — no row for that spec on this
+                // call, a record with no spec identity, a verifier that threw —
+                // consumed nothing for want of a reading, not for want of a fault, and
+                // deleting it there drops permission while the fault is still in the
+                // file. A file no record owns is retired without a measurement: nothing
+                // can consume it, so no reading would ever come.
+                reachableDeclineFiles.has(file) &&
+                    !evaluatedDeclineFiles.has(file)
+                    ? stored
+                    : stored.filter((d) => {
+                        const i = budget.findIndex((c) => c.file === file &&
+                            c.kind === d.kind &&
+                            c.helper === d.helper &&
+                            c.keptInline === d.keptInline);
+                        if (i === -1)
+                            return false;
+                        budget.splice(i, 1);
+                        return true;
+                    }),
+            ]));
+            try {
+                const latest = (await stateManager.readData()) ?? stateData;
+                await stateManager.appendData({ ...latest, strippedDeclines: kept });
+                stateData.strippedDeclines = kept;
+            }
+            catch (err) {
+                logger.warning("Could not retire the declines this call did not consume — one may authorise a later fault", { error: String(err) });
+            }
+        }
         // A blocking reuse verdict on the delivered files refuses the report. The
         // live verify pass is a one-time checkpoint on a file that keeps changing —
         // the execution fix loop and a post-verification rewrite both edit after it —
@@ -1469,6 +2031,10 @@ export function registerSubmitReportTool(server) {
         // off than one with a disclosed fault (see REUSE_SUBMIT_MAX_REFUSALS). The
         // count is persisted per spec path; a count that cannot be persisted cannot
         // bound anything, so a failed write accepts rather than refuses forever.
+        // Built BEFORE the blocking-verdict refusal below, not inside the report
+        // object: a maintained test goes through the same reuse chain as a generated
+        // one, so its delivered files can fail the same check, and a verdict collected
+        // after the refusal would never refuse anything.
         // `reuseOutcomes` is keyed by basename, so two rows sharing a file name find
         // one record and push one verdict twice — deduplicated by path here, as
         // pendingReuseVerification skips that case on its side. Sorted by file so the
@@ -1484,7 +2050,10 @@ export function registerSubmitReportTool(server) {
                 for (const v of owed)
                     refusals[v.file] = (refusals[v.file] ?? 0) + 1;
                 try {
-                    await stateManager.writeData({ ...stateData, reuseRefusals: refusals });
+                    await stateManager.appendData({
+                        ...stateData,
+                        reuseRefusals: refusals,
+                    });
                 }
                 catch (err) {
                     persisted = false;
@@ -1532,6 +2101,202 @@ export function registerSubmitReportTool(server) {
                 test.expectedToFail = true;
             }
         }
+        // Every file this run wrote, from the server's own records — one canonical
+        // absolute path each, which is also the key an execution is recorded under.
+        // Generated files come from the generators; edited files from the maintenance
+        // triage, narrowed by `rowsLeavingCoverage` to UPDATE and REGENERATE. The rest
+        // cannot be run: DELETE removed the file, VERIFY and IGNORE never edited one,
+        // and a `reportOnly` row only advised a change this run did not make.
+        //
+        // A verdict names the SPEC, never `pomFile`: a POM-backed row edits the page
+        // object, but the execution is recorded against the spec.
+        // A file a DELETE verdict names is gone by report time, so no run is owed for
+        // it. The verdicts keep every recommendation, not the winning one, so one file
+        // can carry both a DELETE and an UPDATE — and the DELETE is what was applied.
+        const deletedPaths = new Set(maintenanceSections.flatMap((section) => (section.data.maintenanceVerdicts ?? [])
+            .filter((verdict) => verdict?.action === DriftAction.Delete &&
+            verdict?.reportOnly !== true)
+            .map((verdict) => canonicalTestPath(verdict.testFilePath))));
+        const filesWritten = new Map();
+        // When each generated path was last written, so a run recorded before that
+        // write is not credited for the bytes that replaced it.
+        const generatedAt = new Map();
+        for (const section of maintenanceSections) {
+            for (const [generated, record] of Object.entries(section.data.generatedTests ?? {}))
+                if (!deletedPaths.has(generated)) {
+                    filesWritten.set(generated, "generated");
+                    if (typeof record?.generatedAt === "number")
+                        generatedAt.set(generated, record.generatedAt);
+                }
+            for (const verdict of rowsLeavingCoverage(section.data.maintenanceVerdicts)) {
+                // A rename UPDATE moves the spec before it is executed, so the run is
+                // recorded under the new name while `testFilePath` keeps the old one.
+                const raw = verdict._suggestedNewFile?.trim() || verdict.testFilePath.trim();
+                if (!raw)
+                    continue;
+                // Canonical because that is how an execution is keyed: a checkout under a
+                // symlinked temp or home directory spells one file two ways.
+                const key = canonicalTestPath(raw);
+                if (!filesWritten.has(key) && !deletedPaths.has(key))
+                    filesWritten.set(key, "updated");
+            }
+        }
+        // The LATEST run of each file, because a re-run replaces the record. An edited
+        // file needs a run of the edit, so its pre-edit baseline does not answer for
+        // it — `phase` is what tells the two apart. A generated file has no baseline,
+        // so any run of it is a run of what was written.
+        const executions = new Map(maintenanceSections.flatMap((section) => Object.entries(section.data.testExecutions ?? {}).map(([file, record]) => [
+            file,
+            {
+                phase: String(record?.phase ?? ""),
+                executedAt: String(record?.executedAt ?? ""),
+            },
+        ])));
+        // A record is never removed once written, so a file the agent generated and
+        // then deleted would object forever — and name a path that is not there. What
+        // is gone owes no run. Unreadable counts as gone: a false objection about a
+        // file nobody can open is worse than the silence.
+        const written = [];
+        for (const [file, how] of filesWritten) {
+            if (!(await pathExists(file)))
+                continue;
+            const run = executions.get(file);
+            written.push({
+                file,
+                how,
+                recordedPhase: run?.phase,
+                executedAt: run?.executedAt,
+                generatedAt: generatedAt.get(file),
+            });
+        }
+        // The counts a reader compares at a glance, from the same two sets the check
+        // below joins — so a shortfall here is exactly the files it names.
+        const executionCoverage = {
+            generated: written.filter((f) => f.how === "generated").length,
+            updated: written.filter((f) => f.how === "updated").length,
+            executed: written.filter(runOfWhatWasWritten).length,
+        };
+        // A skipped test is not an execution. Refuse before writing a report so the
+        // agent must execute every delivered plan test instead of declaring a time
+        // constraint in a Skipped row and ending the run.
+        const registeredPlanTestIds = new Set(Array.isArray(stateData.plan?.plannedTests)
+            ? stateData.plan.plannedTests
+                .map((test) => test?.plannedTestId?.trim())
+                .filter((id) => !!id)
+            : []);
+        const skippedTests = isPlanOnlyMode()
+            ? []
+            : skippedDeliveredTests(dedupedNewTests.filter((test) => registeredPlanTestIds.has((test.plannedTestId ?? "").trim())), params.testResults);
+        if (skippedTests.length > 0) {
+            errorResult = toolError(`Cannot submit the report: ${skippedTests.length} registered plan test${skippedTests.length === 1 ? "" : "s"} ${skippedTests
+                .map((test) => `${test.plannedTestId?.trim() || test.testId}`)
+                .join(", ")} ${skippedTests.length === 1 ? "has" : "have"} no non-skipped execution result. ` +
+                "Do not skip because you believe you are low on context or time, or because you speculate that another attempt will not help. " +
+                contextGaugeSentence() +
+                "Run each remaining test with skyramp_execute_test, include its Pass or Fail result in testResults, then call skyramp_submit_report again.");
+            return errorResult;
+        }
+        // A planned UI test with no report entry is a recording that never happened.
+        // `deliveredMatchesPlan` already raises it and already accepts an answer, and
+        // that is how one run shipped a 14-test plan with ZERO UI tests: a single
+        // skyramp_export_zip, a trace that came out polluted, and an answer blaming
+        // the recorder. Refuse while the run has recorded fewer times than it planned
+        // UI tests; past that it has genuinely tried each one and the answer stands.
+        //
+        // WHY THE RETRY IS NOT FUTILE, and why the message says so: a successful
+        // skyramp_export_zip DRAINS the recorder and closes the browser, so the next
+        // recording starts from an empty buffer. Nothing the agent can read says that,
+        // and that run reasoned the opposite and stopped one call short of a clean
+        // trace.
+        const undeliveredUi = isPlanOnlyMode() || planUnreadable
+            ? []
+            : undeliveredPlannedUiTests(stateData.plan?.plannedTests ?? [], dedupedNewTests);
+        const plannedUiCount = planUnreadable
+            ? 0
+            : plannedUiTests(stateData.plan?.plannedTests ?? []).length;
+        // ATTEMPTS, so one more recording always answers a refusal and the gate opens
+        // after at most `plannedUiCount` of them. The refusal cap is the second bound,
+        // for the agent that resubmits having recorded nothing: this check is meant to
+        // cost a recording, never the whole run.
+        const recordings = traceExportAttempts();
+        if (undeliveredUi.length > 0 &&
+            recordings < plannedUiCount &&
+            uiDeliveryRefusals() < MAX_UI_DELIVERY_REFUSALS) {
+            const refusal = countUiDeliveryRefusal();
+            const ids = undeliveredUi
+                .map((test) => test.plannedTestId.trim())
+                .join(", ");
+            errorResult = toolError(`Cannot submit the report: ${undeliveredUi.length} registered UI plan test${undeliveredUi.length === 1 ? "" : "s"} ` +
+                `${ids} ${undeliveredUi.length === 1 ? "has" : "have"} no entry in newTestsCreated, and this run recorded ` +
+                `${recordings} trace${recordings === 1 ? "" : "s"} for ${plannedUiCount} planned UI test${plannedUiCount === 1 ? "" : "s"}. ` +
+                "Do not skip because you believe you are low on context or time, or because you speculate that another attempt will not help. " +
+                contextGaugeSentence() +
+                "A successful skyramp_export_zip clears the recording buffer and closes the browser, so the next recording starts clean — " +
+                "a trace that came out polluted is a reason to record again, not a reason to stop. " +
+                "Record each remaining test in its own pass (browser_navigate to the start URL, the flow, skyramp_export_zip, skyramp_ui_test_generation), " +
+                "add it to newTestsCreated with its plannedTestId, then call skyramp_submit_report again. " +
+                `The plan and every answer you have given are in the state file and survive this refusal (refusal ${refusal} of ${MAX_UI_DELIVERY_REFUSALS}).`);
+            return errorResult;
+        }
+        // A planned test dropped because the run says it was running out.
+        //
+        // `deliveredMatchesPlan` raises "planned but not delivered" and suggests
+        // "add the test to the report, or record in the report why it was dropped".
+        // Run 9dfc8405 recorded the reason seven times — "this run exhausted its
+        // working budget" — and shipped 2 of 9 planned tests with the report
+        // ACCEPTED. It wrote that at 46% of a 1M context window with no warning from
+        // anywhere, and the word appears nowhere in its reasoning: the budget was not
+        // a finding, it was a sentence that closed an objection.
+        //
+        // This refuses that ONE sentence, not a budget. A test blocked by something
+        // outside the run answers and ships exactly as before, which is why the
+        // message says what a reason that stands looks like.
+        //
+        // Answers from earlier calls count too: one that closed the objection on
+        // submit N still closes it on N+1 without being re-sent, and a gate reading
+        // only this call would be walked past by not repeating it.
+        const answerText = new Map();
+        const carriedAnswers = Array.isArray(stateData.reportObjections?.answeredObjections)
+            ? stateData.reportObjections.answeredObjections
+            : [];
+        for (const entry of carriedAnswers) {
+            const id = entry
+                ?.objection?.objectionId;
+            const answer = entry?.answer;
+            if (typeof id === "string" && typeof answer === "string")
+                answerText.set(id, answer);
+        }
+        for (const entry of params.answers ?? []) {
+            if (typeof entry?.objectionId === "string" &&
+                typeof entry?.answer === "string")
+                answerText.set(entry.objectionId, entry.answer);
+        }
+        const droppedForBudget = isPlanOnlyMode() || planUnreadable
+            ? []
+            : undeliveredPlannedTests(stateData.plan?.plannedTests ?? [], dedupedNewTests).filter((test) => citesBudget(answerText.get(`deliveredMatchesPlan:${test.plannedTestId.trim()}`)));
+        if (droppedForBudget.length > 0 &&
+            budgetExcuseRefusals() < MAX_BUDGET_EXCUSE_REFUSALS) {
+            const refusal = countBudgetExcuseRefusal();
+            const ids = droppedForBudget
+                .map((test) => test.plannedTestId.trim())
+                .join(", ");
+            const plural = droppedForBudget.length === 1;
+            errorResult = toolError(`Cannot submit the report: ${droppedForBudget.length} planned test${plural ? "" : "s"} ` +
+                `${ids} ${plural ? "is" : "are"} missing from newTestsCreated, and the answer given for ` +
+                `${plural ? "it" : "each"} is that the run was short of budget, context or time. ` +
+                "That is not a reason this report accepts. " +
+                contextGaugeSentence() +
+                "A reason that stands names something outside the run that stopped the test: a service that is not " +
+                "running, a branch that no longer exists, a credential this run does not hold, a behaviour the " +
+                "application will not reach. Running low is not one of those — it is a reason to write the test now, " +
+                "with the rest of the report already built. " +
+                `Write the missing test${plural ? "" : "s"}, add ${plural ? "it" : "them"} to newTestsCreated with the ` +
+                "plannedTestId, and call skyramp_submit_report again — or replace the answer with what actually " +
+                "stopped it. " +
+                `The plan, the report and every answer you have given are in the state file and survive this refusal ` +
+                `(refusal ${refusal} of ${MAX_BUDGET_EXCUSE_REFUSALS}).`);
+            return errorResult;
+        }
         // Report-time checks on what the customer will read. They need no plan, so a
         // run without one still gets them.
         const reportChecks = [
@@ -1541,6 +2306,15 @@ export function registerSubmitReportTool(server) {
             ...(isPlanOnlyMode()
                 ? []
                 : runPostExecutionCheck("deliveredTestRan", "deliveredTestRan", () => checkEveryDeliveredTestRan(dedupedNewTests, params.testResults))),
+            // Every lane, not just testbot: both records are written whenever the
+            // tools run, and a file written and never run is the same defect
+            // wherever it happens. Silent when the run recorded nothing — an older
+            // state file has no `generatedTests`, and the check must not read that
+            // as "nothing was run". Skipped in the plan-only lane, which has no
+            // application to run anything against.
+            ...(isPlanOnlyMode()
+                ? []
+                : runPostExecutionCheck("testRanOnThisServer", "testRanOnThisServer", () => checkEveryWrittenTestRan(written))),
         ];
         // Run against an EMPTY plan when none was submitted, never skipped: the gate
         // above covers contract and integration only. An empty plan raises exactly
@@ -1548,7 +2322,14 @@ export function registerSubmitReportTool(server) {
         let objections;
         let changeTable;
         {
-            const postExecution = runPostExecutionChecks(stateData.plan ?? { plannedTests: [], registrationNumber: 0, answers: [], openObjections: [], answeredObjections: [] }, dedupedNewTests, params.testResults, params.issuesFound ?? [], isPlanOnlyMode(), 
+            const postExecution = runPostExecutionChecks(stateData.plan ??
+                {
+                    plannedTests: [],
+                    registrationNumber: 0,
+                    answers: [],
+                    openObjections: [],
+                    answeredObjections: [],
+                }, dedupedNewTests, params.testResults, params.issuesFound ?? [], isPlanOnlyMode(), 
             // The triage's own verdicts, not this tool's input, so the join is against
             // what the run is recorded as having edited — and only the rows that left a
             // test standing and were actually applied, so a no-op assessment, a deletion
@@ -1610,7 +2391,10 @@ export function registerSubmitReportTool(server) {
             // objection and answers it in the same call: fixing it stops the check
             // raising it, so matching against this call alone called the answer unknown
             // and objected to the agent for doing both (run 33946409570, sb19).
-            const answerable = [...raised, ...previouslyRaised.map((entry) => entry.objection)];
+            const answerable = [
+                ...raised,
+                ...previouslyRaised.map((entry) => entry.objection),
+            ];
             const reportStageObjections = [
                 ...raised,
                 ...unknownAnswerObjections(answerable, acknowledged, {
@@ -1623,24 +2407,31 @@ export function registerSubmitReportTool(server) {
             // their silence is not evidence: only a call carrying results can resolve an
             // earlier objection.
             const judgedThisCall = (params.testResults ?? []).length > 0;
+            // These verifiers read the server's own records, not `testResults`, so
+            // they reach a verdict on every call. An empty resubmission leaves them
+            // judged, and an objection they no longer raise is resolved — without
+            // this it would vanish from the report and sit in `raisedObjections`
+            // for the rest of the run with nothing able to clear it.
+            const stateBackedVerifiers = new Set(["testRanOnThisServer"]);
+            const judged = (objection) => judgedThisCall || stateBackedVerifiers.has(objection.verifier);
             // Resolved = raised earlier, absent from a call that could have raised it.
             // One that comes back drops out: publishing it as both says two things.
             const resolvedObjections = [
                 ...previouslyResolved,
-                ...(judgedThisCall
-                    ? previouslyRaised
-                        .filter((entry) => !raisedNow.has(answerKey(entry.objection)))
-                        .map((entry) => ({
-                        objection: entry.objection,
-                        resolvedBy: `submission ${submissionNumber}`,
-                    }))
-                    : []),
+                ...previouslyRaised
+                    .filter((entry) => judged(entry.objection) &&
+                    !raisedNow.has(answerKey(entry.objection)))
+                    .map((entry) => ({
+                    objection: entry.objection,
+                    resolvedBy: `submission ${submissionNumber}`,
+                })),
             ].filter((entry, index, all) => !raisedNow.has(answerKey(entry.objection)) &&
                 all.findIndex((other) => answerKey(other.objection) === answerKey(entry.objection)) === index);
             const answeredReportObjections = [];
             const openReportObjections = [];
             for (const objection of reportStageObjections) {
-                const answer = answerFor(objection, acknowledged) ?? carriedByKey.get(answerKey(objection))?.answer;
+                const answer = answerFor(objection, acknowledged) ??
+                    carriedByKey.get(answerKey(objection))?.answer;
                 if (answer)
                     answeredReportObjections.push({ objection, answer });
                 else
@@ -1715,14 +2506,19 @@ export function registerSubmitReportTool(server) {
                 // corroborate a claim that an existing test covers the change.
                 const editedPaths = [];
                 for (const row of rowsLeavingCoverage(stateData.maintenanceVerdicts)) {
-                    for (const full of [row?.testFilePath, row?.pomFile]) {
+                    for (const full of [
+                        row?.testFilePath,
+                        row?.pomFile,
+                    ]) {
                         const path = typeof full === "string" ? full.trim() : "";
                         if (path)
                             editedPaths.push(path);
                     }
                 }
                 const maintainedByChange = new Map();
-                for (const entry of Array.isArray(stateData.plan?.maintains) ? stateData.plan.maintains : []) {
+                for (const entry of Array.isArray(stateData.plan?.maintains)
+                    ? stateData.plan.maintains
+                    : []) {
                     const file = String(entry?.file ?? "").trim();
                     if (!file || !Array.isArray(entry?.changes))
                         continue;
@@ -1742,7 +2538,9 @@ export function registerSubmitReportTool(server) {
                 for (const objection of objections) {
                     if (!objection.objectionId.startsWith(CHANGE_OBJECTION_PREFIX))
                         continue;
-                    const answer = typeof objection.answer === "string" ? objection.answer.trim() : "";
+                    const answer = typeof objection.answer === "string"
+                        ? objection.answer.trim()
+                        : "";
                     if (answer)
                         answerByChange.set(objection.objectionId.slice(CHANGE_OBJECTION_PREFIX.length), answer);
                 }
@@ -1750,7 +2548,8 @@ export function registerSubmitReportTool(server) {
                     const id = String(change?.id ?? "").trim();
                     const testedBy = dedupedNewTests
                         .map((test) => (test.plannedTestId ?? "").trim())
-                        .filter((plannedTestId) => plannedTestId && (changesByCandidate.get(plannedTestId) ?? []).includes(id));
+                        .filter((plannedTestId) => plannedTestId &&
+                        (changesByCandidate.get(plannedTestId) ?? []).includes(id));
                     const answer = answerByChange.get(id);
                     const maintainedBy = maintainedByChange.get(id) ?? [];
                     return {
@@ -1771,7 +2570,7 @@ export function registerSubmitReportTool(server) {
             // The report is the deliverable, so a failed state write must not cost
             // it; the answer is simply repeated on the next call.
             try {
-                await stateManager.writeData({
+                await stateManager.appendData({
                     ...stateData,
                     reportObjections: {
                         answeredObjections: [
@@ -1785,9 +2584,8 @@ export function registerSubmitReportTool(server) {
                                 objection,
                                 submission: firstRaisedAt.get(answerKey(objection)) ?? submissionNumber,
                             })),
-                            ...(judgedThisCall
-                                ? []
-                                : previouslyRaised.filter((entry) => !raisedNow.has(answerKey(entry.objection)))),
+                            ...previouslyRaised.filter((entry) => !judged(entry.objection) &&
+                                !raisedNow.has(answerKey(entry.objection))),
                         ],
                         resolvedObjections,
                         submissionCount: submissionNumber,
@@ -1801,44 +2599,20 @@ export function registerSubmitReportTool(server) {
         const report = {
             businessCaseAnalysis: params.businessCaseAnalysis,
             newTestsCreated: sanitizedNewTests,
-            additionalRecommendations: dedupedRecommendations.map(normalizeRepository),
+            additionalRecommendations: dedupedRecommendations,
             // Report wire format keeps main's original `fileName` (basename) — testFilePath is
             // an internal-only field, needed for matching but never meant to reach the report.
-            testMaintenance: testMaintenance
-                ? await Promise.all(testMaintenance.map(async ({ testFilePath, pomFile, ...row }) => {
-                    // `pomFile` is the file skyramp_actions told the agent to edit;
-                    // `testFilePath` stays the spec, which is what ran. Name both when
-                    // they differ, or a page-object edit is reported against the spec.
-                    // Maintenance rows still carry the absolute path here, so the
-                    // assertion summary uses an EXACT canonical-path lookup — no
-                    // basename ambiguity. This is what carries the maintenance
-                    // honesty labels (nothing-to-verify vs verified) into the
-                    // report instead of leaving them as tool text the agent can
-                    // paraphrase.
-                    const record = stateData.assertionOutcomes?.[canonicalTestPath(testFilePath)];
-                    const assertions = record
-                        ? await rederiveAssertionOutcome(record)
-                        : undefined;
-                    return normalizeRepository({
-                        ...row,
-                        fileName: path.basename(testFilePath),
-                        ...(pomFile &&
-                            path.basename(pomFile) !== path.basename(testFilePath)
-                            ? { editedFileName: path.basename(pomFile) }
-                            : {}),
-                        ...(assertions ? { assertions } : {}),
-                    });
-                }))
-                : undefined,
+            testMaintenance: maintenanceRows,
             // videoPath is filled from the run's execution records; testFilePath is the
             // match-only key and is stripped from the wire format, the same line drawn for
             // testMaintenance's own testFilePath above (downstream scoring scripts traverse
             // these objects and don't expect it).
             testResults: params.testResults.map((row) => {
-                const { testFilePath: _tfp, ...wire } = attachVideoPath(normalizeRepository(row), stateData.executionVideos);
+                const { testFilePath: _tfp, ...wire } = attachVideoPath(row, stateData.executionVideos);
                 return wire;
             }),
             issuesFound,
+            executionCoverage,
             nextSteps: params.nextSteps ?? [],
             ...(changeTable ? { changes: changeTable } : {}),
             ...(objections ? { objections } : {}),
@@ -1861,11 +2635,64 @@ export function registerSubmitReportTool(server) {
                 outputFile: reportPath,
                 elapsedMs: elapsed,
             });
+            // The report is on disk, so this call is past every refusal in the handler
+            // — including the one a failed write above would have raised. See
+            // stripDeliveredGateMarkers for why the accepted path is the only one that
+            // may remove a decline.
+            const stripped = await stripDeliveredGateMarkers(stateData.reuseOutcomes, retrofitViews, changedSet);
+            // Only ADDS here. Retirement already happened above, before any refusal
+            // could return, so this call has nothing left to draw down.
+            if (Object.keys(stripped).length > 0) {
+                // Recorded so a later call in this run can read them back — the removal is
+                // for the customer, not for our own gates. A record that cannot be
+                // persisted would make that call refuse a declined fault, so the failure
+                // is logged where the next refusal can be explained by it.
+                try {
+                    // Re-read rather than spread the `stateData` this call opened with. The
+                    // objections block above has already persisted its own record, and
+                    // carryForwardRootFields carries `reportObjections` only when the
+                    // incoming value is undefined — so writing the call-start copy back would
+                    // revert the submission count and re-raise answers this call resolved.
+                    const latest = (await stateManager.readData()) ?? stateData;
+                    await stateManager.appendData({
+                        ...latest,
+                        // Merged per file, never replaced: a later submission that strips a
+                        // second marker from one file must not forget the first, which is
+                        // still a decline this run made.
+                        //
+                        // A decline this call did NOT consume is retired. The fault it covered
+                        // is gone, and permission that covers no fault authorises the next one
+                        // instead — which nobody declined. A marker left in a file retires the
+                        // same way, through `stale-allow`; this is that rule for the records.
+                        strippedDeclines: Object.fromEntries([
+                            ...new Set([
+                                ...Object.keys(latest.strippedDeclines ?? {}),
+                                ...Object.keys(stripped),
+                            ]),
+                        ].map((file) => [
+                            file,
+                            [
+                                ...(latest.strippedDeclines?.[file] ?? []),
+                                ...(stripped[file] ?? []),
+                            ].map((d) => {
+                                // The `file` tag is a runtime aid for retirement, not part of
+                                // the record: the record is already keyed by file.
+                                const { file: _tag, ...rest } = d;
+                                return rest;
+                            }),
+                        ])),
+                    });
+                }
+                catch (err) {
+                    logger.warning("Could not record the declines removed from the delivered files — a further submission may refuse one of them", { error: String(err) });
+                }
+            }
             // Addressed to the AGENT in the second person, each naming a next move: the
             // report is already written when this returns and the tool can be called
             // again, so the instruction is actionable. An answered objection is
             // published but not listed back, which would read as a second demand.
-            const open = objections?.filter((objection) => objection.stage === "post-execution" && objection.answer === undefined) ?? [];
+            const open = objections?.filter((objection) => objection.stage === "post-execution" &&
+                objection.answer === undefined) ?? [];
             return {
                 content: [
                     {