@skyramp/mcp 0.3.6-rc.2.ac20 → 0.3.7

package/build/tools/runExistingTestsTool.js

@@ -440,95 +440,6 @@ const defaultDeps = {
     },
     now: () => new Date().toISOString(),
 };
-/** Worst outcome wins for a file. `error` (never reached its assertions) outranks
- *  `fail` so a collection failure is never reported as an assertion failure, and
- *  `skipped` sits below everything: it only wins when nothing else ran. */
-const STATUS_RANK = {
-    skipped: 0,
-    pass: 1,
-    fail: 2,
-    error: 3,
-};
-/**
- * Reduce a run's flat result list to one outcome per spec file.
- *
- * This is the only place that knows BOTH what the framework reported and what the
- * run asked it for, which is what `complete` needs. Deriving it later from the
- * results alone is not possible: a file re-run for one test looks identical to a
- * file whose other tests silently vanished.
- *
- * `partialFiles` are the files a `file::test title` selector narrowed to a subset of
- * their tests — the one narrowing this tool applies itself, and so the only one it
- * can state with certainty.
- */
-export function summarizeFilesInRun(results, opts) {
-    const byFile = new Map();
-    for (const r of results) {
-        if (typeof r.file !== "string" || r.file === "")
-            continue;
-        const key = r.absoluteFile ?? r.file;
-        byFile.set(key, [...(byFile.get(key) ?? []), r]);
-    }
-    return [...byFile.values()].map((group) => {
-        const counts = { pass: 0, fail: 0, error: 0, skipped: 0 };
-        for (const r of group)
-            counts[r.status] = (counts[r.status] ?? 0) + 1;
-        const status = group.reduce((a, b) => STATUS_RANK[b.status] > STATUS_RANK[a.status] ? b : a).status;
-        const first = group[0];
-        return {
-            file: first.file,
-            ...(first.absoluteFile ? { absoluteFile: first.absoluteFile } : {}),
-            status,
-            counts,
-            complete: !isPartial(first, opts.partialFiles),
-            errors: group
-                .filter((r) => r.status === "fail" || r.status === "error")
-                .map((r) => `${r.testId}: ${r.message ?? r.status}`),
-            durationMs: group.reduce((sum, r) => sum + (r.durationMs ?? 0), 0),
-        };
-    });
-}
-/** A selector spelling and a result spelling need not agree — the selector is
- *  repo-relative, the result may be absolute or framework-root-relative — so match
- *  on a path-segment suffix in either direction. */
-function isPartial(r, partialFiles) {
-    if (partialFiles.size === 0)
-        return false;
-    const candidates = [r.file, r.absoluteFile].filter((c) => typeof c === "string" && c !== "");
-    for (const sel of partialFiles) {
-        for (const c of candidates) {
-            if (c === sel || c.endsWith("/" + sel) || sel.endsWith("/" + c))
-                return true;
-        }
-    }
-    return false;
-}
-/** Placeholder identity for a record that names no suite because none resolved.
- *  Deliberately not a valid suiteIdOf output, so it can never collide with one. */
-export const NO_RUNNABLE_SUITE = "(no runnable suite)";
-/** Stable identity for ONE configured suite. A service can declare several
- *  (workspace.yml testSuites), so its name alone collides — two suites under one
- *  service would share a slot and the later would mask the other instead of both
- *  counting. */
-export function suiteIdOf(cfg) {
-    return `${cfg.serviceName}::${cfg.framework}::${cfg.testRunCommand}`;
-}
-/** The files a selector narrowed to individual tests. A bare `file` selector runs
- *  the whole file; `file::test title` does not. */
-export function partialFilesFrom(selectors) {
-    const out = new Set();
-    for (const sel of selectors) {
-        const [file, ...rest] = sel.split("::");
-        // A trailing `::` names no title, so every builder drops it and the whole file
-        // runs. Treating it as partial would throw away a real status.
-        if (rest.join("::").trim() === "")
-            continue;
-        const trimmed = file.trim();
-        if (trimmed)
-            out.add(trimmed);
-    }
-    return out;
-}
 /** Appends a run record into UnifiedAnalysisState.externalTestResults for the
  *  given repo section. Best-effort: a state failure never fails the run. */
 async function persistExternalRun(stateFile, repository, record) {
@@ -552,7 +463,7 @@ async function persistExternalRun(stateFile, repository, record) {
  * fully injectable for tests.
  */
 export async function runExternalTests(params, deps = defaultDeps) {
-    const mode = params.mode;
+    const mode = params.mode ?? "confirm";
     const selectors = params.testSelectors ?? [];
     let effective = selectors;
     let truncated = false;
@@ -575,11 +486,6 @@ export async function runExternalTests(params, deps = defaultDeps) {
         if (params.stateFile) {
             await persistExternalRun(params.stateFile, params.repository, {
                 ...skippedRun,
-                files: [],
-                // No run config resolved, so there is no suite to identify — and a service
-                // name here would read as one. The reader never keys on it (the record is
-                // skipped, and skipped records are dropped first), so name it for what it is.
-                suite: NO_RUNNABLE_SUITE,
                 mode,
                 ranAt: deps.now(),
                 repository: params.repository,
@@ -612,8 +518,6 @@ export async function runExternalTests(params, deps = defaultDeps) {
             if (params.stateFile) {
                 await persistExternalRun(params.stateFile, params.repository, {
                     ...routedOut,
-                    files: [],
-                    suite: suiteIdOf(cfg),
                     mode,
                     ranAt: deps.now(),
                     repository: params.repository,
@@ -638,13 +542,8 @@ export async function runExternalTests(params, deps = defaultDeps) {
         };
         perSuite.push(suiteResult);
         if (params.stateFile) {
-            const files = summarizeFilesInRun(suiteResult.results, {
-                partialFiles: partialFilesFrom(routing.kept),
-            });
             await persistExternalRun(params.stateFile, params.repository, {
                 ...suiteResult,
-                files,
-                suite: suiteIdOf(cfg),
                 mode,
                 ranAt: deps.now(),
                 repository: params.repository,
@@ -676,7 +575,8 @@ export function registerRunExistingTestsTool(server) {
                 .describe("Spec files to run (paths relative to the run command's cwd), optionally `file::test title` to also filter by name. Omit to run the whole configured suite."),
             mode: z
                 .enum(["confirm", "verify"])
-                .describe("REQUIRED, and the only thing that marks a run as before or after the edit: confirm = the pre-edit baseline (a scoped run establishing which tests the change breaks; disables the suite's fail-fast cap, e.g. Playwright's maxFailures, so ALL breakages are counted), verify = the re-run after you edited. Passing confirm for a post-edit run overwrites the baseline with the fixed result, and the report then shows a repair as having never been broken."),
+                .optional()
+                .describe("confirm (default): scoped run to establish which tests a change breaks; disables the suite's fail-fast cap (e.g. Playwright's maxFailures) so ALL breakages are counted. verify: re-run after an edit."),
             project: z
                 .string()
                 .optional()
@@ -735,7 +635,7 @@ export function registerRunExistingTestsTool(server) {
             AnalyticsService.pushMCPToolEvent(TOOL_NAME, errorResult, {
                 workspacePath: params.workspacePath,
                 service: params.service ?? "",
-                mode: params.mode,
+                mode: params.mode ?? "confirm",
             }).catch((err) => {
                 logger.warning("Analytics event failed", { error: String(err) });
             });

package/build/tools/submitReportTool.js

@@ -12,9 +12,11 @@ import { StateManager, runArtifactDir, getTestsRepoDir, } from "../utils/Analysi
 import { toolError, testFileMatches } from "../utils/utils.js";
 import { matchesApprovedPlan } from "../utils/planMatchKeys.js";
 import { isTestbotEnabled } from "../utils/featureFlags.js";
-import { findInvalidSourceCitations, findUnchangedFileClaims, listChangedFiles, listChangedFilesAcross, } from "../utils/reportVerification.js";
+import { findInvalidSourceCitations, findUnchangedFileClaims, listChangedFiles, listChangedFilesAcross, listChangedFilesAbs, } from "../utils/reportVerification.js";
 import { getReportLanguage, isEnforcedReportLanguage, findLanguageViolations, findLanguageNearMisses, reportLanguageDisplayName, } from "../utils/reportLanguage.js";
-import { rederiveReuseOutcome, reuseChainSkipped, } from "./code-refactor/reuse-state.js";
+import { canonicalTestPath, findAssertionRecordByFileName, rederiveAssertionOutcome, } from "./code-refactor/assertion-state.js";
+import { rederiveReuseOutcome, reuseChainSkipped, samePath, } from "./code-refactor/reuse-state.js";
+import { retrofitGate, } from "./code-refactor/retrofit-state.js";
 // SKYR-3879 Path B: which testTypes the register-plan checkpoint gates. Mirrors
 // the generation tools actually wired to planGuard (batch-scenario/integration,
 // contract) — UI and E2E are on a separate blueprint-grounded pipeline and are
@@ -84,96 +86,6 @@ const MAINTENANCE_CHANGE_ACTIONS = new Set([
     DriftAction.Regenerate,
     DriftAction.Delete,
 ]);
-const EXTERNAL_TO_EXECUTION_STATUS = {
-    pass: TestExecutionStatus.Pass,
-    fail: TestExecutionStatus.Fail,
-    error: TestExecutionStatus.Error,
-};
-/** Does this run's file outcome describe `knownPath`?
- *
- *  `absoluteFile` is the framework's own path resolved against the root it reported,
- *  so it names one file and is compared exactly. An outcome without one is refused:
- *  a relative spelling is a suffix, and a suffix cannot separate
- *  `packages/a/tests/x.spec.ts` from `packages/b/tests/x.spec.ts`. Guessing there and
- *  guarding the guess is what this deliberately does not do — a missing status is a
- *  row that reads Unknown, which is what it reads today; a wrong one is a false claim
- *  about someone's tests.
- *
- *  The cost is real and accepted: a suite running inside a container reports the
- *  container's root, which cannot equal the host path discovery recorded, so those
- *  repos get no status until the run records a root the report can line up. */
-function outcomeMatches(outcome, knownPath) {
-    return (typeof outcome.absoluteFile === "string" &&
-        path.resolve(outcome.absoluteFile) === path.resolve(knownPath));
-}
-/** One line describing what the suite saw, for a row whose status came from the run
- *  rather than from an execution the agent drafted a summary for. Without it the
- *  rendered cell is a bare `Error` or `Pass` with nothing behind it. */
-function describeOutcome(o) {
-    // Defended like the record reads around it: a malformed outcome must not throw
-    // out of the handler and take the whole report submission with it.
-    const c = o.counts ?? { pass: 0, fail: 0, error: 0, skipped: 0 };
-    const parts = [
-        c.pass ? `${c.pass} passed` : "",
-        c.fail ? `${c.fail} failed` : "",
-        c.error ? `${c.error} errored` : "",
-        c.skipped ? `${c.skipped} skipped` : "",
-    ].filter(Boolean);
-    const head = `${parts.join(", ") || "no tests reported"} in the repo's own suite`;
-    // Adapter messages carry stack traces, so collapse whitespace before truncating:
-    // an embedded newline would break the maintenance row this lands in.
-    const first = (o.errors ?? [])[0]?.replace(/\s+/g, " ").trim();
-    return first ? `${head} — ${first.slice(0, 200)}` : head;
-}
-function externalStatusesFor(records, knownPath) {
-    // LATEST per suite, then WORST across suites. Both halves matter: a suite re-run
-    // after another edit supersedes its own earlier verdict, so an obsolete failure
-    // must not outlive the fix that repaired it; but two different suites can each
-    // own the same file, and a pass in one must not mask a failure in the other.
-    const RANK = { pass: 0, fail: 1, error: 2 };
-    const statusIn = (mode) => {
-        const latestPerSuite = new Map();
-        for (const record of records ?? []) {
-            if (record.mode !== mode || record.skipped || !record.environmentHealthy)
-                continue;
-            // A suite that stopped on --max-failures left tests unrun and does not say
-            // which, so no file it touched can stand as covered. The adapter reports this;
-            // it is not a guess. (The tool forces --max-failures=0 for confirm, so this is
-            // reachable on a verify re-run under the repo's own cap.)
-            if (record.diagnostics?.maxFailuresBail)
-                continue;
-            const hit = (record.files ?? []).find((o) => outcomeMatches(o, knownPath));
-            if (!hit)
-                continue;
-            const key = record.suite ?? "";
-            const prior = latestPerSuite.get(key);
-            // `ranAt` is an ISO timestamp, so a lexical compare is chronological. The
-            // newest run wins BEFORE it is judged: a later partial re-run supersedes an
-            // earlier complete one, and must leave the row unknown rather than let the
-            // stale complete outcome stand in for it.
-            if (!prior || record.ranAt >= prior.at)
-                latestPerSuite.set(key, { at: record.ranAt, outcome: hit });
-        }
-        let worst;
-        for (const { outcome } of latestPerSuite.values()) {
-            // `skipped` means every test in the file was skipped — it was not exercised,
-            // and TestExecutionStatus.Skipped means a deliberate decision not to run it.
-            if (!outcome.complete || outcome.status === "skipped")
-                continue;
-            if (!worst || RANK[outcome.status] > RANK[worst.status])
-                worst = outcome;
-        }
-        return worst;
-    };
-    const before = statusIn("confirm");
-    const after = statusIn("verify");
-    return {
-        before: before && EXTERNAL_TO_EXECUTION_STATUS[before.status],
-        after: after && EXTERNAL_TO_EXECUTION_STATUS[after.status],
-        beforeDetail: before && describeOutcome(before),
-        afterDetail: after && describeOutcome(after),
-    };
-}
 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
@@ -643,14 +555,14 @@ const testMaintenanceSchema = z.object({
         "For passing runs: count and timing, e.g. '4 passed in 15.09s'. " +
         "For failing runs: failure name and one-line root cause, e.g. " +
         "'FAILED test_foo — assert 403 got 200, auth middleware not enforced'. " +
-        "Pass an empty string when you ran nothing yourself — the server then fills this from the repo suite's own run — and for VERIFY/IGNORE entries where nothing ran at all. Omit the whole entry, never this field."),
+        "Empty string for VERIFY/IGNORE entries where no before-execution was run."),
     afterDetails: z
         .string()
         .describe("One line only — no embedded newlines, no raw HTTP headers or JSON blobs. " +
         "For passing runs: count and timing, e.g. '5 passed in 10.96s'. " +
         "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'. " +
-        "Pass an empty string when you ran nothing yourself — the server then fills this from the repo suite's own run — and for VERIFY/IGNORE/DELETE entries where nothing ran at all. Omit the whole entry, never this field."),
+        "Empty string for VERIFY/IGNORE/DELETE entries where no after-execution was run."),
     // Server-populated from stateFile execution records — never supplied by the LLM.
     beforeStatus: z.nativeEnum(TestExecutionStatus),
     afterStatus: z.nativeEnum(TestExecutionStatus),
@@ -731,7 +643,26 @@ function computeReportMetrics(params) {
  * gets `chainSkipped: true` (SKYR-4220), the one claim that is exactly about the
  * reuse tool NOT having run. Applies to every test type: UI tests carry the POM
  * fields, API tests the shared-helper ones. */
-async function attachReuseOutcome(test, outcomes, handOffs) {
+/** Attach the assertion-enhancement summary to a report row.
+ *
+ *  How the row finds its record: records are keyed by the test file's full
+ *  path, but a report row only carries a file NAME. So the match compares
+ *  basenames, then checks testType and repository. When more than one record
+ *  still matches, the row gets NO summary — attaching the wrong spec's
+ *  numbers is worse than attaching none.
+ *
+ *  The numbers are server-derived and re-computed from the delivered file at
+ *  report time — the report narrative is LLM-authored, these numbers are not.
+ *  What a reader can conclude: `executionCount: 0` = generated but never
+ *  executed; no `assertions` field at all = the enhance tool never ran for
+ *  the file and it never executed. */
+async function attachAssertionOutcome(test, outcomes, checkouts) {
+    const record = findAssertionRecordByFileName(outcomes, test, checkouts);
+    if (!record)
+        return test;
+    return { ...test, assertions: await rederiveAssertionOutcome(record) };
+}
+async function attachReuseOutcome(test, outcomes, handOffs, retrofits = []) {
     // 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)];
@@ -742,6 +673,18 @@ async function attachReuseOutcome(test, outcomes, handOffs) {
         ? record
         : undefined;
     const derived = found ? await rederiveReuseOutcome(found) : undefined;
+    // 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);
@@ -1101,42 +1044,12 @@ export function registerSubmitReportTool(server) {
                     : MAINTENANCE_CHANGE_ACTIONS.has(m.action)
                         ? TestExecutionStatus.Unknown
                         : TestExecutionStatus.Skipped;
-                // A suite run answers only for a row whose default is Unknown. VERIFY and
-                // IGNORE are Skipped by decision, not for want of a result, and testbot
-                // drops both from the rendered table.
-                const external = externalStatusesFor(stateData.externalTestResults, m.testFilePath);
-                const beforeStatus = recorded?.executionBefore?.status ??
-                    (defaultBeforeStatus === TestExecutionStatus.Unknown
-                        ? external.before
-                        : undefined) ??
-                    defaultBeforeStatus;
-                const afterStatus = recorded?.executionAfter?.status ??
-                    (defaultAfterStatus === TestExecutionStatus.Unknown
-                        ? external.after
-                        : undefined) ??
-                    defaultAfterStatus;
+                const beforeStatus = recorded?.executionBefore?.status ?? defaultBeforeStatus;
+                const afterStatus = recorded?.executionAfter?.status ?? defaultAfterStatus;
                 // Trim before checking — a whitespace-only string is semantically blank and
                 // must not satisfy the "drafted a summary" requirement.
-                // The agent's drafted summary wins; otherwise a status that came from
-                // the suite run carries the run's own line, so the rendered cell is
-                // never a bare verdict with nothing behind it.
-                //
-                // Only when there is NO recorded execution. A file the agent ran itself
-                // owes a drafted summary, and filling it here would satisfy the check
-                // below on the agent's behalf whenever the two statuses happened to
-                // agree — silently dropping the requirement.
-                //
-                // And only where the STATUS came from the suite too. A VERIFY or DELETE
-                // row keeps its Skipped default, so a line saying "1 passed in the repo's
-                // own suite" beside it contradicts the very cell it annotates.
-                const beforeFromSuite = defaultBeforeStatus === TestExecutionStatus.Unknown &&
-                    !recorded?.executionBefore;
-                const afterFromSuite = defaultAfterStatus === TestExecutionStatus.Unknown &&
-                    !recorded?.executionAfter;
-                const beforeDetails = detail?.beforeDetails?.trim() ||
-                    (beforeFromSuite ? (external.beforeDetail ?? "") : "");
-                const afterDetails = detail?.afterDetails?.trim() ||
-                    (afterFromSuite ? (external.afterDetail ?? "") : "");
+                const beforeDetails = detail?.beforeDetails?.trim() ?? "";
+                const afterDetails = detail?.afterDetails?.trim() ?? "";
                 if (recorded?.executionBefore && !beforeDetails)
                     missingDetails.push(`${displayName} (beforeDetails)`);
                 if (recorded?.executionAfter && !afterDetails)
@@ -1156,6 +1069,11 @@ export function registerSubmitReportTool(server) {
                 "Add a testMaintenanceDetails entry with the missing field(s), drafted from the execution output you already saw.");
             return errorResult;
         }
+        // SKYR-4276 A4: retrofits (pre-existing generated tests the reuse pass edited)
+        // that still stand in the working tree, resolved once here and attached to the
+        // rows below; an unexecuted one refuses the report (inside the SKYR-3883 block,
+        // which already enumerates the working tree).
+        let retrofitViews = [];
         // 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
@@ -1216,6 +1134,17 @@ export function registerSubmitReportTool(server) {
                             `Files with actual working-tree changes:\n${changedList || "  (none)"}`);
                         return errorResult;
                     }
+                    const changedFilesAbs = await listChangedFilesAbs([
+                        repoRoot,
+                        getTestsRepoDir(),
+                        ...Object.values(fullState?.relatedRepos ?? {}).map((section) => section.repositoryPath),
+                    ]);
+                    const gate = await retrofitGate(stateData, changedFilesAbs, repoRoot);
+                    retrofitViews = gate.views;
+                    if (gate.refusal) {
+                        errorResult = toolError(gate.refusal);
+                        return errorResult;
+                    }
                 }
                 catch (err) {
                     // Never block a valid report because verification itself failed (path not a
@@ -1253,7 +1182,16 @@ export function registerSubmitReportTool(server) {
         // generation — downstream scoring scripts don't expect them and fail if
         // they encounter these string fields while traversing the object.
         // Also normalize each item's `repository` (blank → undefined).
-        const sanitizedNewTests = await Promise.all(dedupedNewTests.map(({ scenarioFile: _sf, traceFile: _tf, frontendTrace: _ft, ...rest }) => attachReuseOutcome(normalizeRepository(rest), stateData.reuseOutcomes, stateData.reuseHandOffs)));
+        // Checkout roots let the assertion-record matcher verify a candidate
+        // record actually lives in the row's repo (basename collisions across
+        // repos must not publish one spec's proof-of-work under another's name).
+        const assertionCheckouts = await stateManager
+            .listRepoCheckouts()
+            .catch(() => []);
+        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);
+            return attachAssertionOutcome(row, stateData.assertionOutcomes ?? {}, assertionCheckouts);
+        }));
         const report = {
             businessCaseAnalysis: params.businessCaseAnalysis,
             newTestsCreated: sanitizedNewTests,
@@ -1262,10 +1200,25 @@ export function registerSubmitReportTool(server) {
             // an internal-only field, needed for matching but never meant to reach the report.
             // TODO(multi-repo maintenance): map(normalizeRepository) once testMaintenanceSchema
             // has a repository field (see TODO above).
-            testMaintenance: testMaintenance?.map(({ testFilePath, ...row }) => ({
-                ...row,
-                fileName: path.basename(testFilePath),
-            })),
+            testMaintenance: testMaintenance
+                ? await Promise.all(testMaintenance.map(async ({ testFilePath, ...row }) => {
+                    // 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 {
+                        ...row,
+                        fileName: path.basename(testFilePath),
+                        ...(assertions ? { assertions } : {}),
+                    };
+                }))
+                : undefined,
             // 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

package/build/tools/workspace/initializeWorkspaceTool.js

@@ -1,12 +1,68 @@
 import { z } from "zod";
 import { WorkspaceConfigManager, serviceSchema, } from "../../workspace/workspace.js";
 import fs from "fs/promises";
+import fsSync from "fs";
+import path from "path";
 import yaml from "js-yaml";
 import { logger } from "../../utils/logger.js";
 import { AnalyticsService } from "../../services/AnalyticsService.js";
 import { SKYRAMP_IMAGE_VERSION } from "../../utils/versions.js";
 import { validateAndConsumeScanToken } from "./initScanWorkspaceTool.js";
 import { upsertServicesByRepo } from "./serviceUpsert.js";
+import { isInsideDir } from "../../utils/gitStaging.js";
+import { EXECUTOR_VIDEOS_DIR, EXECUTOR_WORK_DIR, isInsideExecutorWorkDir, } from "../../utils/executorWorkDir.js";
+// Test delivery stages each service's whole testDirectory with
+// `git add -- <testDirectory>`, so a testDirectory that encloses the executor's
+// videos commits every .webm. This tool runs before any test is generated, so it
+// is the only point where the choice can still be redirected.
+/**
+ * First service whose `testDirectory` collides with the executor's working area,
+ * or undefined when none does. Two ways to collide, and both have to be rejected
+ * here: the directory sits inside `.skyramp` (which the generation tools refuse
+ * to write into, so accepting it would deadlock the agent between the two
+ * checks), or it encloses `.skyramp/videos` (`.`, "" or the repo root), which
+ * makes delivery commit every video. Relative paths resolve against
+ * `workspacePath`; an absolute one is matched on its own segments, so another
+ * repo's `.skyramp` is caught too.
+ *
+ * A directory that is itself a git repository root is rejected for the same
+ * reason, whichever repo it belongs to. The enclosure test above is anchored on
+ * the PRIMARY workspace's videos path, so a multi-repo entry naming another
+ * repo's root — `/work/repo-b` while workspacePath is `/work/repo-a` — slips
+ * past it: repo A's videos are not inside repo B. The executor writes
+ * `.skyramp/videos` at a repo root, so being one is the collision.
+ */
+function badTestDirectoryResult(bad) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Service "${bad.serviceName}" sets testDirectory to "${bad.testDirectory}", which collides with ${EXECUTOR_WORK_DIR}, the executor's working area: a directory inside it is never delivered, and one that encloses ${EXECUTOR_VIDEOS_DIR}/ makes delivery commit every execution video. Use a dedicated test path — the service's framework-configured test directory, or tests/skyramp. If this service came from the existing ${EXECUTOR_WORK_DIR}/workspace.yml, re-run with force: true and the full corrected services array.`,
+            },
+        ],
+        isError: true,
+    };
+}
+/** Whether `dir` is the top of a git checkout. `.git` is a directory in a normal
+ *  clone and a file in a worktree, so existence is the test. */
+function isGitRepositoryRoot(dir) {
+    return fsSync.existsSync(path.join(dir, ".git"));
+}
+function findBadTestDirectory(workspacePath, services) {
+    const workspaceVideos = path.resolve(workspacePath, EXECUTOR_VIDEOS_DIR);
+    for (const svc of services) {
+        const dir = svc.testDirectory;
+        if (dir === undefined)
+            continue;
+        const resolved = path.resolve(workspacePath, dir);
+        if (isInsideExecutorWorkDir(resolved) ||
+            isInsideDir(workspaceVideos, resolved) ||
+            isGitRepositoryRoot(resolved)) {
+            return { serviceName: svc.serviceName, testDirectory: dir };
+        }
+    }
+    return undefined;
+}
 function getExecutorVersion() {
     return SKYRAMP_IMAGE_VERSION;
 }
@@ -92,6 +148,40 @@ export function registerInitializeWorkspaceTool(server) {
                     isError: false,
                 };
             }
+            if (!params.services || params.services.length === 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: "No services provided. Follow the scanning instructions from skyramp_init_scan to discover services, then call this tool again.",
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Both checks above and below are input-only, so they run before
+            // validateAndConsumeScanToken: that
+            // token is single-use, and a rejection after it would make the corrected
+            // retry this error asks for fail with "Invalid or expired scanToken". It
+            // is also before initialize()/updateMetadata(), which both write
+            // workspace.yml (workspace.ts:431, :460) — a later rejection would leave
+            // an initialized file behind and the retry would then short-circuit as
+            // "already initialized".
+            const badIncoming = findBadTestDirectory(workspacePath, params.services);
+            if (badIncoming)
+                return badTestDirectoryResult(badIncoming);
+            // Merge mode writes the MERGED set, so a bad testDirectory already in the
+            // file would be re-persisted. Checked on the merge, not on the existing
+            // services alone, so replacing a bad entry with a corrected one of the
+            // same identity is still the way out. Reading the file is side-effect
+            // free, so this rejection belongs up here with the other two rather than
+            // after the token is spent.
+            const mergeInto = params.merge && alreadyExists ? await manager.read() : undefined;
+            if (mergeInto) {
+                const badMerged = findBadTestDirectory(workspacePath, upsertServicesByRepo([...(mergeInto.services ?? [])], params.services));
+                if (badMerged)
+                    return badTestDirectoryResult(badMerged);
+            }
             // scanToken is required for fresh init; for edits (force:true on an
             // existing workspace.yml) the caller supplies the full services array
             // directly and we skip the token check.
@@ -120,33 +210,15 @@ export function registerInitializeWorkspaceTool(server) {
                     };
                 }
             }
-            if (!params.services || params.services.length === 0) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: "No services provided. Follow the scanning instructions from skyramp_init_scan to discover services, then call this tool again.",
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-            // Initialize (fresh) or read (merge into existing). Merge mode preserves
-            // the existing primary repo identity + previously-registered services;
-            // initialize() would reset both, dropping other repos' services.
-            let config;
-            if (params.merge && alreadyExists) {
-                config = await manager.read();
-                config = await manager.updateMetadata({
-                    executorVersion: getExecutorVersion(),
-                });
-            }
-            else {
-                config = await manager.initialize();
-                config = await manager.updateMetadata({
-                    executorVersion: getExecutorVersion(),
-                });
-            }
+            // Merge mode skips initialize(): it preserves the existing primary repo
+            // identity + previously-registered services, both of which initialize()
+            // would reset, dropping other repos' services. The file itself was
+            // already read above, for the merged-set check.
+            if (!mergeInto)
+                await manager.initialize();
+            const config = await manager.updateMetadata({
+                executorVersion: getExecutorVersion(),
+            });
             // Batch all service upserts: update in memory, write once (direct YAML
             // write avoids N+1 reads and a mid-loop validation error). Upsert is keyed
             // on the composite (repo, serviceName) — see upsertServicesByRepo — so a