@skyramp/mcp 0.3.0-rc.1 → 0.3.0

package/build/tools/auth/logoutTool.js

@@ -50,7 +50,7 @@ Logout from Skyramp platform to end your authenticated session.`,
             const recordParams = {
                 prompt: params.prompt,
             };
-            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, recordParams);
+            AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, recordParams).catch((err) => { logger.warning("Analytics event failed", { error: String(err) }); });
         }
     });
 }

package/build/tools/code-refactor/codeReuseTool.js

@@ -102,7 +102,7 @@ export function registerCodeReuseTool(server) {
                 testFile: params.testFile,
                 language: params.language,
                 framework: params.framework,
-            });
+            }).catch((err) => { logger.warning("Analytics event failed", { error: String(err) }); });
         }
     });
 }

package/build/tools/code-refactor/modularizationTool.js

@@ -120,7 +120,7 @@ After modularization, if errors remain, call skyramp_fix_errors.
                 testFile: params.testFile,
                 language: params.language ?? "",
                 testType: params.testType ?? "",
-            });
+            }).catch((err) => { logger.warning("Analytics event failed", { error: String(err) }); });
         }
     });
 }

package/build/tools/executeSkyrampTestTool.js

@@ -8,6 +8,7 @@ import { TestExecutionStatus } from "../types/TestExecution.js";
 import { getWorkspaceBaseUrl } from "../utils/workspaceAuth.js";
 import { ProgrammingLanguage, TestType } from "../types/TestTypes.js";
 import { StateManager } from "../utils/AnalysisStateManager.js";
+import { TestSource } from "../types/TestAnalysis.js";
 import { logger } from "../utils/logger.js";
 import { toolError } from "../utils/utils.js";
 const TOOL_NAME = "skyramp_execute_test";
@@ -77,6 +78,34 @@ export function registerExecuteSkyrampTestTool(server) {
                 errorResult = toolError(`testFile must be an absolute path, got: ${params.testFile}`);
                 return errorResult;
             }
+            // Deterministic external-test guard (SKYR-3924): this tool runs Skyramp-generated
+            // tests in the executor and cannot run a repo's native (user-written) suite, so a
+            // run on an external test only errors (e.g. pytest import/collection failure).
+            // If the stateFile records this test as external, skip execution — the prompt asks
+            // the agent to exclude them, and this enforces it. Best-effort and conservative:
+            // only skip on a positive external match; any state-read issue falls through to
+            // normal execution, and a not-found test (e.g. a newly generated one) is not skipped.
+            if (params.stateFile) {
+                try {
+                    const stateManager = StateManager.fromStatePath(params.stateFile);
+                    const stateData = await stateManager.readRepoData(params.repository);
+                    const entry = stateData?.existingTests?.find((t) => t.testFile === params.testFile);
+                    if (entry?.source === TestSource.External) {
+                        logger.info(`Skipping execution of external test ${params.testFile} — native suites are not run by ${TOOL_NAME}`);
+                        return {
+                            content: [
+                                {
+                                    type: "text",
+                                    text: `Skipped execution: ${params.testFile} is marked external in the state file. ${TOOL_NAME} runs Skyramp-generated tests only; external (native) suites are not executed here.`,
+                                },
+                            ],
+                        };
+                    }
+                }
+                catch (err) {
+                    logger.warning(`External-test guard could not read stateFile (${err.message}); proceeding with execution`);
+                }
+            }
             // Send initial progress
             await sendProgress(0, 100, "Starting test execution...");
             // Always resolve workspace config for dockerNetwork (host networking)
@@ -187,7 +216,7 @@ If this failed with a 401 status code, ask the user for the authentication token
                 workspacePath: params.workspacePath,
                 language: params.language,
                 testType: params.testType,
-            });
+            }).catch((err) => { logger.warning("Analytics event failed", { error: String(err) }); });
         }
     });
 }

package/build/tools/fixErrorTool.js

@@ -64,7 +64,7 @@ export function registerFixErrorTool(server) {
             AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
                 prompt: params.prompt,
                 testFile: params.testFile,
-            });
+            }).catch((err) => { logger.warning("Analytics event failed", { error: String(err) }); });
         }
     });
 }

package/build/tools/one-click/oneClickTool.js

@@ -184,7 +184,7 @@ export function registerOneClickTool(server) {
         finally {
             AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
                 workflow: params.workflow,
-            });
+            }).catch((err) => { logger.warning("Analytics event failed", { error: String(err) }); });
         }
     });
 }

package/build/tools/test-management/actionsTool.js

@@ -6,7 +6,8 @@ import { TestType } from "../../types/TestTypes.js";
 import * as fs from "fs";
 import * as path from "path";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
-import { toolError, testFileMatches } from "../../utils/utils.js";
+import { toolError } from "../../utils/utils.js";
+import { isTestFile } from "../../prompts/test-recommendation/scopeAssessment.js";
 import { buildRenameStrategy, buildFileRenameStrategy, buildUpdateStrategy, buildRegenerateStrategy, buildDeleteStrategy, buildUpdateFileInstruction, buildRegenerateFileInstruction, } from "../../prompts/test-maintenance/actionsInstructions.js";
 /**
  * Compute a suggested new filename when an endpoint is renamed.
@@ -58,9 +59,9 @@ const recommendationSchema = z.object({
     action: z
         .nativeEnum(DriftAction)
         .refine((a) => a !== DriftAction.Ignore, {
-        message: "Use ignoredTestFiles for IGNORE tests; omit IGNORE entries from recommendations.",
+        message: "Omit IGNORE entries entirely — a discovered test you don't recommend is automatically treated as needing no action.",
     })
-        .describe("Drift action assigned by the LLM health assessment. Never IGNORE — omit the recommendation and use ignoredTestFiles instead."),
+        .describe("The maintenance action for this test (UPDATE, REGENERATE, DELETE, or VERIFY). Do not send IGNORE — omit no-action tests from `recommendations` entirely; anything you leave out is recorded as needing no action."),
     testType: z
         .nativeEnum(TestType)
         .describe("Type of this test — carried through to the maintenance report."),
@@ -89,6 +90,18 @@ const recommendationSchema = z.object({
         "auth changes, new request params, removed fields, or other drift-related changes. " +
         "Example: 'Added stock_count: int (ge=0, default=0) to ProductBase. " +
         "Test hits GET /products — assert stock_count is present and non-negative.'"),
+    editSites: z
+        .array(z.object({
+        line: z.number().int().min(1).describe("1-based line number of the edit site in the current file."),
+        anchor: z
+            .string()
+            .min(1)
+            .describe("A short verbatim snippet from that line (copied exactly from the file you read) so the edit can be located without re-scanning."),
+        change: z.string().optional().describe("What to change at this site (e.g. 'add work_pool_name to this payload')."),
+    }))
+        .optional()
+        .describe("For a large UPDATE file, the concrete per-site edits you already located while reading it — one entry per place that must change, with a verbatim anchor. " +
+        "Surfaced to the apply step as a checklist so it edits each site directly instead of re-grepping/re-paging the file. Provide this whenever an UPDATE touches more than a couple of sites."),
     renamedEndpoints: z
         .array(z.object({
         oldPath: z.string().describe("Previous endpoint path"),
@@ -109,17 +122,9 @@ const actionsSchema = {
         .describe("The owner/repo whose analysis section to act on (e.g. 'letsramp/api-insight'). In a multi-repo run, ALWAYS set it — the primary's owner/repo for the primary repo's tests, or a related repo's owner/repo for that repo's section — within the run-scoped stateFile. Omit only for a single-repo run."),
     recommendations: z
         .array(recommendationSchema)
-        .optional()
-        .describe("Drift recommendations from skyramp_analyze_test_health. Omit IGNORE entries. Omitting this field results in no maintenance actions."),
-    ignoredTestFiles: z
-        .array(z.string().refine((p) => path.isAbsolute(p), {
-        message: "ignoredTestFiles entries must be absolute paths — use the exact path reported by skyramp_analyze_changes or skyramp_analyze_test_health. A bare filename is ambiguous when multiple discovered tests share that basename.",
-    }))
-        .optional()
         .default([])
-        .describe("Absolute path of every existing test you assessed during drift analysis and decided needs no action — use the exact path reported by skyramp_analyze_changes or skyramp_analyze_test_health. " +
-        "Every test discovered by skyramp_analyze_changes must appear in either `recommendations` or here — " +
-        "otherwise this call fails, naming the test(s) you didn't account for."),
+        .describe("Drift recommendations from skyramp_analyze_test_health — include only tests that need an action (UPDATE, REGENERATE, DELETE, or VERIFY). " +
+        "Any discovered test you don't list here is automatically treated as needing no action, so never add IGNORE entries or enumerate the no-action tests yourself. Defaults to an empty array."),
 };
 const TOOL_NAME = "skyramp_actions";
 export function registerActionsTool(server) {
@@ -130,7 +135,7 @@ export function registerActionsTool(server) {
             idempotentHint: false,
             openWorldHint: true,
         },
-        description: `Execute test maintenance actions — final step of the unified Test Health Analysis Flow. Call this once per run even when no tests need action — it is the only point where every assessed existing test is reconciled (via \`recommendations\` + \`ignoredTestFiles\`) before the run moves on.`,
+        description: `Execute test maintenance actions — final step of the unified Test Health Analysis Flow. Call this once per run even when no tests need action (pass \`recommendations: []\`) — it is where the maintenance verdicts are persisted before the run moves on. Supply only the tests that need an action; any discovered test you omit from \`recommendations\` is treated as needing no action and recorded automatically, so you never enumerate the no-action tests yourself.`,
         inputSchema: actionsSchema,
     }, async (args) => {
         let errorResult;
@@ -195,10 +200,26 @@ export function registerActionsTool(server) {
                 // Catalog membership is the safety boundary — prevents editing non-test files.
                 const isRelevantExternal = (externalTestFiles.has(resolvedFile) || externalTestFiles.has(rec.testFilePath));
                 const isInAnyKnownCatalog = isSkyramp || isRelevantExternal;
-                if (!isInAnyKnownCatalog) {
-                    logger.warning(`Skipping ${rec.action} for unknown test (not in scanned catalog): ${rec.testFilePath}`);
+                // Discovery is relevance-scoped, not exhaustive — it can miss a real test file the
+                // agent correctly identifies from the diff (e.g. an e2e Playwright spec/POM under a
+                // dir discovery didn't rank relevant). Rejecting those as "hallucinated" silently
+                // drops correct maintenance verdicts, leaving report.testMaintenance empty even
+                // though the edit was applied (SKYR — D2 bucket B1). Accept an uncataloged
+                // recommendation when its testFilePath is a REAL file on disk, inside the repo root,
+                // whose name matches a test-file pattern. The path-traversal guard above already
+                // bounds it to repoRoot; isTestFile bounds it to test files (never app source), so
+                // this preserves the anti-hallucination guarantee (an invented path fails existsSync).
+                const isRealUncatalogedTest = !isInAnyKnownCatalog &&
+                    isTestFile(resolvedFile) &&
+                    (!repoRoot || resolvedFile.startsWith(repoRoot + path.sep) || resolvedFile === repoRoot) &&
+                    fs.existsSync(resolvedFile);
+                if (!isInAnyKnownCatalog && !isRealUncatalogedTest) {
+                    logger.warning(`Skipping ${rec.action} for unknown test (not in scanned catalog, not a real test file): ${rec.testFilePath}`);
                     return;
                 }
+                if (isRealUncatalogedTest) {
+                    logger.info(`Accepting uncataloged but real test file discovery missed: ${rec.testFilePath}`);
+                }
                 const isActionable = [DriftAction.Update, DriftAction.Regenerate, DriftAction.Delete].includes(rec.action);
                 // No write access to a related repo's checkout — convert any edit-requiring
                 // action to VERIFY so the finding still surfaces without attempting a write that
@@ -217,21 +238,27 @@ export function registerActionsTool(server) {
                     });
                     return;
                 }
-                if (isActionable && !isSkyramp && !isRelevantExternal) {
+                if (isActionable && !isSkyramp && !isRelevantExternal && !isRealUncatalogedTest) {
                     logger.warning(`Skipping ${rec.action} for irrelevant external test: ${rec.testFilePath}`);
                     return;
                 }
-                // REGENERATE and DELETE on external tests are report-only — convert to VERIFY so
-                // the finding surfaces to the developer without touching the file.
-                if (isRelevantExternal && !isSkyramp &&
+                // A real-but-uncataloged test is treated as external (user-authored) for policy.
+                const isExternalTarget = isRelevantExternal || isRealUncatalogedTest;
+                // REGENERATE and DELETE on external tests are report-only — the file is never
+                // touched, but the verdict keeps its REAL action (not flattened to VERIFY) so the
+                // report renders it as a deletion/regeneration RECOMMENDATION the developer applies
+                // manually. `reportOnly: true` makes the apply loops below skip it (B2 — a flattened
+                // VERIFY read to the D2 judge as "uncertain", hiding a correct DELETE call).
+                if (isExternalTarget && !isSkyramp &&
                     (rec.action === DriftAction.Regenerate || rec.action === DriftAction.Delete)) {
                     recommendations.push({
                         testFilePath: resolvedFile,
-                        action: DriftAction.Verify,
+                        action: rec.action,
+                        reportOnly: true,
                         testType: rec.testType,
                         endpoint: rec.endpoint,
                         priority: rec.priority ?? RecommendationPriority.Medium,
-                        rationale: `[external test — needs manual review] ${rec.rationale}`,
+                        rationale: `[external test — report-only ${rec.action}, apply manually] ${rec.rationale}`,
                         estimatedWork: rec.estimatedWork ?? EstimatedWork.Small,
                         updateInstructions: "",
                         renamedEndpoints: [],
@@ -261,32 +288,31 @@ export function registerActionsTool(server) {
                     estimatedWork: rec.estimatedWork ?? EstimatedWork.Small,
                     updateInstructions: rec.updateInstructions ?? "",
                     renamedEndpoints: rec.renamedEndpoints ?? [],
+                    ...(rec.editSites?.length ? { editSites: rec.editSites } : {}),
                 });
             });
-            // Use the validated `recommendations` array (built above), not the raw
-            // `args.recommendations` — a hallucinated/rejected path (not in the catalog, or
-            // outside the repo root) never made it into `recommendations`, so it must not
-            // count as "accounted for" here either. Counting the raw input would let a typo'd
-            // testFilePath mask a real file that never received a valid recommendation.
-            const accountedForNames = [
-                ...recommendations.map((r) => r.testFilePath),
-                ...(args.ignoredTestFiles ?? []),
-            ];
-            const unaccountedFor = testAnalysisResults
+            // Derive the no-action set here instead of asking the LLM to enumerate it.
+            // The caller supplies only the tests that need an action (`recommendations`); every
+            // other discovered test is, by definition, no-action. The tool already holds the full
+            // catalog (`testAnalysisResults`), so the ignored set is just the complement — computed
+            // in O(catalog) with zero LLM tokens. The previous design required the LLM to echo back
+            // an absolute path for every discovered test and hard-rejected otherwise (SKYR-3906);
+            // on a 1,000+ test monorepo the LLM cannot round-trip that list reliably, so it never
+            // converged and the run timed out (SKYR-3938). The report is built solely from
+            // `maintenanceVerdicts` (the validated recommendations), persisted below at
+            // decision-time — that persistence is what prevents a decided-upon entry from silently
+            // vanishing at report time; the ignored set is a complete, accurate record for free.
+            const recommendedPaths = new Set(recommendations.map((r) => r.testFilePath));
+            const ignoredTestFiles = testAnalysisResults
                 .map((t) => t.testFile)
-                .filter((testFile) => !accountedForNames.some((name) => testFileMatches(testFile, name)));
-            if (unaccountedFor.length > 0) {
-                errorResult = toolError(`${unaccountedFor.length} existing test(s) assessed by skyramp_analyze_test_health are not accounted for: ${unaccountedFor.join(", ")}. ` +
-                    "Add a recommendation for each one that needs UPDATE/REGENERATE/DELETE/VERIFY, or add its path to ignoredTestFiles if it needs no action.");
-                return errorResult;
-            }
+                .filter((testFile) => !recommendedPaths.has(testFile));
             // So skyramp_submit_report can read this back instead of re-asking the LLM.
             // Must fail loud — edits below apply regardless, so a swallowed failure here
             // would let edits ship with no testMaintenance in the final report.
             try {
                 await stateManager.writeRepoData({
                     ...stateData,
-                    ignoredTestFiles: args.ignoredTestFiles ?? [],
+                    ignoredTestFiles,
                     maintenanceVerdicts: recommendations.map((r) => ({
                         testFilePath: r.testFilePath,
                         action: r.action,
@@ -317,6 +343,10 @@ export function registerActionsTool(server) {
             const regenerateByFile = new Map();
             const deleteByFile = new Map();
             for (const rec of recommendations) {
+                // Report-only verdicts (external DELETE/REGENERATE) are recorded for the report
+                // but never applied — keep them out of every apply map.
+                if (rec.reportOnly)
+                    continue;
                 if (rec.action === DriftAction.Delete) {
                     const existing = deleteByFile.get(rec.testFilePath);
                     if (!existing || priorityRank[rec.priority] > priorityRank[existing.priority]) {
@@ -494,7 +524,12 @@ export function registerActionsTool(server) {
                 .map((rec) => {
                 const editTarget = rec.pomFile ?? rec.testFilePath;
                 const current_content = testFileContentMap.get(editTarget);
-                return { file: editTarget, context: rec.updateInstructions, ...(current_content !== undefined && { current_content }) };
+                return {
+                    file: editTarget,
+                    context: rec.updateInstructions,
+                    ...(rec.editSites?.length ? { edit_sites: rec.editSites } : {}),
+                    ...(current_content !== undefined && { current_content }),
+                };
             });
             if (updateContext.length > 0) {
                 llmInstructionsObj.update_context = updateContext;
@@ -549,7 +584,7 @@ export function registerActionsTool(server) {
             }
             AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
                 repositoryPath,
-            });
+            }).catch((err) => { logger.warning("Analytics event failed", { error: String(err) }); });
         }
     });
 }

package/build/tools/test-management/actionsTool.test.js

@@ -51,7 +51,7 @@ async function writeStateFile(dir, existingTests, repositoryAnalysis) {
     }), "utf-8");
     return stateFile;
 }
-describe("registerActionsTool — completeness check (SKYR-3906)", () => {
+describe("registerActionsTool — verdict reconciliation & persistence (SKYR-3906, SKYR-3938)", () => {
     let handler;
     let tmpDirs = [];
     beforeAll(() => {
@@ -85,32 +85,25 @@ describe("registerActionsTool — completeness check (SKYR-3906)", () => {
         expect(result.content).toBeDefined();
         expect(result.isError).toBeUndefined();
     });
-    it("succeeds when every existing test is covered by ignoredTestFiles", async () => {
+    it("derives the ignored set as the catalog complement of recommendations — no LLM enumeration (SKYR-3938)", async () => {
+        // The caller supplies only actionable recommendations; every other discovered test is
+        // recorded as ignored automatically. The LLM payload is O(recommendations) — independent of
+        // catalog size — which is the fix for the large-repo timeout where the LLM had to echo back
+        // every path. (Server-side derivation is still O(catalog): filter the catalog by a
+        // recommendations Set.)
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
         tmpDirs.push(tmpDir);
         const testFile = path.join(tmpDir, "unrelated_test.py");
         await fs.writeFile(testFile, "# test");
         const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
-        const result = await handler({
-            stateFile,
-            ignoredTestFiles: [testFile],
-        });
+        // No recommendations at all — the sole discovered test is recorded as ignored.
+        const result = await handler({ stateFile, recommendations: [] });
         expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        expect(written.ignoredTestFiles).toEqual([testFile]);
+        expect(written.maintenanceVerdicts).toEqual([]);
     });
-    it("rejects a bare basename in ignoredTestFiles at the schema level — ambiguous across files sharing that name", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
-        tmpDirs.push(tmpDir);
-        const testFile = path.join(tmpDir, "unrelated_test.py");
-        await fs.writeFile(testFile, "# test");
-        const stateFile = await writeStateFile(tmpDir, [{ testFile, source: TestSource.Skyramp }]);
-        const result = await handler({
-            stateFile,
-            ignoredTestFiles: ["unrelated_test.py"],
-        });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("must be absolute paths");
-    });
-    it("rejects a recommendation with action: IGNORE at the schema level — must use ignoredTestFiles", async () => {
+    it("rejects a recommendation with action: IGNORE at the schema level — must simply be omitted", async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
         tmpDirs.push(tmpDir);
         const testFile = path.join(tmpDir, "unrelated_test.py");
@@ -119,12 +112,16 @@ describe("registerActionsTool — completeness check (SKYR-3906)", () => {
         const result = await handler({
             stateFile,
             recommendations: [{ testFilePath: testFile, action: DriftAction.Ignore, rationale: "No change needed", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
-            // ignoredTestFiles intentionally omitted — IGNORE must not silently persist via recommendations.
+            // IGNORE must not silently persist via recommendations — it must simply be omitted.
         });
         expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("Use ignoredTestFiles for IGNORE tests");
+        expect(result.content[0].text).toContain("Omit IGNORE entries entirely");
     });
-    it("fails with a descriptive error naming the file missing from both recommendations and ignoredTestFiles", async () => {
+    it("treats an existing test omitted from recommendations as needing no action — no completeness gate (SKYR-3938)", async () => {
+        // The prior hard-reject forced the LLM to echo back every discovered test, which is
+        // infeasible on large repos (1,000+ tests) and caused the run to spin until CI timeout.
+        // An omitted test is now silently no-action: the call succeeds, only the covered file
+        // lands in the verdicts, and the dropped file is recorded in the derived ignored set.
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
         tmpDirs.push(tmpDir);
         const coveredFile = path.join(tmpDir, "covered_test.py");
@@ -138,13 +135,16 @@ describe("registerActionsTool — completeness check (SKYR-3906)", () => {
         const result = await handler({
             stateFile,
             recommendations: [{ testFilePath: coveredFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
-            // droppedFile intentionally absent from both recommendations and ignoredTestFiles
+            // droppedFile intentionally absent from recommendations
         });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("secret_test.py");
-        expect(result.content[0].text).toContain("not accounted for");
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        expect(written.maintenanceVerdicts).toEqual([
+            { testFilePath: coveredFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" },
+        ]);
+        expect(written.ignoredTestFiles).toEqual([droppedFile]);
     });
-    it("persists a reconciled maintenanceVerdicts + ignoredTestFiles record to the state file", async () => {
+    it("persists maintenanceVerdicts + a derived ignoredTestFiles record to the state file", async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
         tmpDirs.push(tmpDir);
         const updatedFile = path.join(tmpDir, "orders_contract_test.py");
@@ -155,10 +155,10 @@ describe("registerActionsTool — completeness check (SKYR-3906)", () => {
             { testFile: updatedFile, source: TestSource.Skyramp },
             { testFile: ignoredFile, source: TestSource.Skyramp },
         ]);
+        // Only the actionable test is supplied; ignoredFile is derived as the catalog complement.
         await handler({
             stateFile,
             recommendations: [{ testFilePath: updatedFile, action: DriftAction.Update, rationale: "Field added", testType: TestType.CONTRACT, endpoint: "GET /api/v1/orders" }],
-            ignoredTestFiles: [ignoredFile],
         });
         const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
         expect(written.ignoredTestFiles).toEqual([ignoredFile]);
@@ -168,6 +168,67 @@ describe("registerActionsTool — completeness check (SKYR-3906)", () => {
         // Original existingTests must survive the write-back untouched.
         expect(written.existingTests).toHaveLength(2);
     });
+    it("accepts a real test file discovery missed (uncataloged) instead of dropping it (B1)", async () => {
+        // Discovery is relevance-scoped, so a real e2e spec/POM the agent correctly identifies
+        // can be absent from the catalog. Before B1 its verdict was dropped as "hallucinated",
+        // leaving report.testMaintenance empty even though the edit was applied.
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const cataloged = path.join(tmpDir, "orders_contract_test.py");
+        await fs.writeFile(cataloged, "# test");
+        const e2eDir = path.join(tmpDir, "e2e", "specs");
+        await fs.mkdir(e2eDir, { recursive: true });
+        const uncataloged = path.join(e2eDir, "drafts.spec.ts"); // real on disk, NOT in existingTests
+        await fs.writeFile(uncataloged, "import { test } from '@playwright/test';\ntest('x', async () => {});");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile: cataloged, source: TestSource.Skyramp }]);
+        const result = await handler({
+            stateFile,
+            recommendations: [
+                { testFilePath: uncataloged, action: DriftAction.Update, rationale: "testid moved, re-scope locator", testType: TestType.E2E, endpoint: "/drafts", updateInstructions: "re-scope the badge locator" },
+            ],
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        expect(written.maintenanceVerdicts.map((v) => v.testFilePath)).toContain(uncataloged);
+    });
+    it("still rejects a recommendation for a non-existent (hallucinated) test path (B1 boundary)", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const cataloged = path.join(tmpDir, "orders_contract_test.py");
+        await fs.writeFile(cataloged, "# test");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile: cataloged, source: TestSource.Skyramp }]);
+        const ghost = path.join(tmpDir, "e2e", "does_not_exist.spec.ts"); // matches test pattern but NOT on disk
+        const result = await handler({
+            stateFile,
+            recommendations: [
+                { testFilePath: ghost, action: DriftAction.Update, rationale: "hallucinated", testType: TestType.E2E, endpoint: "/x", updateInstructions: "y" },
+            ],
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        expect(written.maintenanceVerdicts.map((v) => v.testFilePath)).not.toContain(ghost);
+    });
+    it("records external DELETE as a report-only verdict (real action, file untouched) — no VERIFY flattening (B2)", async () => {
+        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
+        tmpDirs.push(tmpDir);
+        const extTest = path.join(tmpDir, "whats_new.spec.ts");
+        await fs.writeFile(extTest, "import { test } from '@playwright/test';\ntest('whats new', async () => {});");
+        const stateFile = await writeStateFile(tmpDir, [{ testFile: extTest, source: TestSource.External }]);
+        const result = await handler({
+            stateFile,
+            recommendations: [
+                { testFilePath: extTest, action: DriftAction.Delete, rationale: "What's New feature removed in this PR", testType: TestType.E2E, endpoint: "/whats-new" },
+            ],
+        });
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        const verdict = written.maintenanceVerdicts.find((v) => v.testFilePath === extTest);
+        expect(verdict).toBeDefined();
+        // The verdict keeps the real DELETE action — NOT flattened to VERIFY (the D2-judge bug).
+        expect(verdict.action).toBe(DriftAction.Delete);
+        // Report-only: the external test file must still exist on disk.
+        await expect(fs.access(extTest)).resolves.toBeUndefined();
+    });
     it("fails loud when persisting maintenanceVerdicts to state fails, instead of silently applying edits anyway", async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
         tmpDirs.push(tmpDir);
@@ -270,9 +331,8 @@ describe("registerActionsTool — completeness check (SKYR-3906)", () => {
     });
     // ── Multi-repo (`repository` param) ─────────────────────────────────────────
     // A run-scoped state file holds the primary repo at the root and each related
-    // repo under `relatedRepos[<owner/repo>]`. `args.repository` must scope both
-    // the completeness check and the maintenanceVerdicts/ignoredTestFiles write-back
-    // to the matching section only.
+    // repo under `relatedRepos[<owner/repo>]`. `args.repository` must scope the
+    // maintenanceVerdicts/ignoredTestFiles write-back to the matching section only.
     async function writeMultiRepoStateFile(stateFile, primary, related) {
         const now = "2026-01-01T00:00:00.000Z";
         await fs.writeFile(stateFile, JSON.stringify({
@@ -295,7 +355,7 @@ describe("registerActionsTool — completeness check (SKYR-3906)", () => {
             },
         }), "utf-8");
     }
-    it("scopes the completeness check and write-back to a related (non-primary) repo section, leaving the primary section untouched", async () => {
+    it("scopes the write-back to a related (non-primary) repo section, leaving the primary section untouched", async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
         tmpDirs.push(tmpDir);
         const primaryDir = path.join(tmpDir, "primary");
@@ -344,7 +404,7 @@ describe("registerActionsTool — completeness check (SKYR-3906)", () => {
             { testFilePath: secondaryTestFile, action: DriftAction.Verify, rationale: "[related repo — no write access, needs manual review] Endpoint removed", testType: TestType.CONTRACT, endpoint: "DELETE /api/v1/reset" },
         ]);
     });
-    it("fails the completeness check for a related repo's missing test, unaffected by the primary repo's own state", async () => {
+    it("scopes the write-back to the related repo section, writing an empty verdict record when nothing needs action (SKYR-3938)", async () => {
         const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "actions-test-"));
         tmpDirs.push(tmpDir);
         const primaryDir = path.join(tmpDir, "primary");
@@ -357,14 +417,20 @@ describe("registerActionsTool — completeness check (SKYR-3906)", () => {
         await fs.writeFile(secondaryTestFile, "# test");
         const stateFile = path.join(tmpDir, "analyze-changes-state.json");
         await writeMultiRepoStateFile(stateFile, { repositoryPath: primaryDir, existingTests: [{ testFile: primaryTestFile, source: TestSource.Skyramp }] }, { repo: "org/secondary", repositoryPath: secondaryDir, existingTests: [{ testFile: secondaryTestFile, source: TestSource.Skyramp }] });
-        // Primary repo's own test is fully accounted for, but that must not satisfy
-        // the related repo's completeness check.
+        // With no completeness gate, a related-repo test the LLM left unlisted is simply
+        // no-action: the call succeeds and writes an empty maintenanceVerdicts to the related
+        // section only, leaving the primary section untouched.
         const result = await handler({
             stateFile,
             repository: "org/secondary",
             recommendations: [],
         });
-        expect(result.isError).toBe(true);
-        expect(result.content[0].text).toContain("secret_test.py");
+        expect(result.isError).toBeUndefined();
+        const written = JSON.parse(await fs.readFile(stateFile, "utf-8"));
+        expect(written.relatedRepos["org/secondary"].data.maintenanceVerdicts).toEqual([]);
+        // The related section's lone test is recorded as ignored (derived complement), scoped
+        // to that section — the primary section stays untouched.
+        expect(written.relatedRepos["org/secondary"].data.ignoredTestFiles).toEqual([secondaryTestFile]);
+        expect(written.maintenanceVerdicts).toBeUndefined();
     });
 });