vibe-coding-master 0.7.48 → 0.7.49

package/README.md

@@ -221,8 +221,15 @@ Controls:
 - `Start`: start a new Claude Code role session
 - `Resume`: resume a saved Claude Code session
 - `Restart`: stop current process and start fresh
+- `Restart With Context`: restart a VCM workflow role and continue from its current task artifacts
 - `Stop`: stop the embedded terminal process
 
+`Restart With Context` is available only for Project Manager, Architect, Coder,
+Tester, and Reviewer. It reuses their existing handoffs, workflow state, Gate
+requests, worktree, and Git state; it does not create a separate context file.
+Translator and Harness Engineer are tool Agents and do not use this workflow-role
+recovery path.
+
 Permission modes:
 
 ```text

package/dist/backend/api/session-routes.js

@@ -1,4 +1,4 @@
-import { isDispatchableRole, isRoleName } from "../../shared/constants.js";
+import { isDispatchableRole, isRoleName, isVcmRoleName } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 export function registerSessionRoutes(app, deps) {
     app.get("/api/tasks/:taskSlug/sessions", async (request) => {
@@ -8,6 +8,9 @@ export function registerSessionRoutes(app, deps) {
     app.post("/api/tasks/:taskSlug/sessions/:role/start", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
+        if (isVcmRoleName(role)) {
+            await deps.roleContextRestartService.clearRole(project.repoRoot, request.params.taskSlug, role);
+        }
         return deps.sessionService.startRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
     });
     app.post("/api/tasks/:taskSlug/sessions/architect/restart-after-planning", async (request, reply) => {
@@ -18,14 +21,38 @@ export function registerSessionRoutes(app, deps) {
     app.post("/api/tasks/:taskSlug/sessions/:role/stop", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
+        if (isVcmRoleName(role)) {
+            await deps.roleContextRestartService.clearRole(project.repoRoot, request.params.taskSlug, role);
+        }
         const session = await deps.sessionService.stopRoleSession(project.repoRoot, request.params.taskSlug, role);
         await deps.translationService.stopSession(session.id);
         deps.roundService.stopSession(session.id);
         return session;
     });
+    app.post("/api/tasks/:taskSlug/sessions/:role/restart-with-context", async (request) => {
+        const project = await requireCurrentProject(deps.projectService);
+        const role = parseVcmRole(request.params.role);
+        if (role === "architect" && deps.architectRestartService.getState(project.repoRoot, request.params.taskSlug)) {
+            throw new VcmError({
+                code: "ARCHITECT_RESTART_CONFLICT",
+                message: "Architect already has a pending post-planning restart.",
+                statusCode: 409
+            });
+        }
+        const existing = await deps.sessionService.getRoleSession(project.repoRoot, request.params.taskSlug, role);
+        await deps.sessionService.assertModelLaunchReady(request.body?.model ?? existing?.model);
+        if (existing) {
+            await deps.translationService.stopSession(existing.id, { clearCache: true });
+            deps.roundService.stopSession(existing.id);
+        }
+        return deps.roleContextRestartService.restart(project.repoRoot, request.params.taskSlug, role, request.body);
+    });
     app.post("/api/tasks/:taskSlug/sessions/:role/restart", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
+        if (isVcmRoleName(role)) {
+            await deps.roleContextRestartService.clearRole(project.repoRoot, request.params.taskSlug, role);
+        }
         const existing = await deps.sessionService.getRoleSession(project.repoRoot, request.params.taskSlug, role);
         await deps.sessionService.assertModelLaunchReady(request.body?.model ?? existing?.model);
         if (existing) {
@@ -37,6 +64,9 @@ export function registerSessionRoutes(app, deps) {
     app.post("/api/tasks/:taskSlug/sessions/:role/resume", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
         const role = parseRole(request.params.role);
+        if (isVcmRoleName(role)) {
+            await deps.roleContextRestartService.clearRole(project.repoRoot, request.params.taskSlug, role);
+        }
         return deps.sessionService.resumeRoleSession(project.repoRoot, request.params.taskSlug, role, request.body);
     });
     app.post("/api/tasks/:taskSlug/sessions/:role/notify-harness", async (request) => {
@@ -70,6 +100,16 @@ function parseRole(role) {
     }
     return role;
 }
+function parseVcmRole(role) {
+    if (!isVcmRoleName(role)) {
+        throw new VcmError({
+            code: "ROLE_CONTEXT_RESTART_UNSUPPORTED",
+            message: `Restart With Context is available only for VCM workflow roles: ${role}`,
+            statusCode: 400
+        });
+    }
+    return role;
+}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {

package/dist/backend/server.js

@@ -13,6 +13,7 @@ import { createAppSettingsService } from "./services/app-settings-service.js";
 import { createCodexBridgeIntegrationService } from "./services/codex-bridge-integration-service.js";
 import { createAutoMemoryService } from "./services/auto-memory-service.js";
 import { createArchitectRestartService } from "./services/architect-restart-service.js";
+import { createRoleContextRestartService } from "./services/role-context-restart-service.js";
 import { createRoleStallDetectorService } from "./services/role-stall-detector-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
 import { createGateReviewService } from "./services/gate-review-service.js";
@@ -144,7 +145,8 @@ export async function createServer(deps, options = {}) {
         commandDispatcher: deps.commandDispatcher,
         translationService: deps.translationService,
         roundService: deps.roundService,
-        architectRestartService: deps.architectRestartService
+        architectRestartService: deps.architectRestartService,
+        roleContextRestartService: deps.roleContextRestartService
     });
     registerArtifactRoutes(app, {
         projectService: deps.projectService,
@@ -301,6 +303,12 @@ export function createDefaultServerDeps(options = {}) {
         sessionService,
         appSettings
     });
+    const roleContextRestartService = createRoleContextRestartService({
+        fs,
+        projectService,
+        taskService,
+        sessionService
+    });
     const messageService = createMessageService({
         fs,
         runtime,
@@ -378,7 +386,8 @@ export function createDefaultServerDeps(options = {}) {
         roundService,
         projectService,
         taskWorkflowService,
-        architectRestartService
+        architectRestartService,
+        roleContextRestartService
     });
     const gatewayService = createGatewayService({
         fs,
@@ -401,7 +410,8 @@ export function createDefaultServerDeps(options = {}) {
         projectService,
         taskService,
         translationWorkerService,
-        architectRestartService
+        architectRestartService,
+        roleContextRestartService
     });
     const claudeHookService = createClaudeHookService({
         projectService,
@@ -419,6 +429,7 @@ export function createDefaultServerDeps(options = {}) {
         jobGuard: createJobGuardService(),
         translationWorkerService,
         architectRestartService,
+        roleContextRestartService,
         roleStallDetector,
         workflowControlService
     });
@@ -466,6 +477,7 @@ export function createDefaultServerDeps(options = {}) {
         taskCloseService,
         taskWorkflowService,
         architectRestartService,
+        roleContextRestartService,
         sessionService,
         artifactService,
         harnessService,

package/dist/backend/services/claude-hook-service.js

@@ -238,6 +238,9 @@ export function createClaudeHookService(deps) {
         if (input.role === "architect") {
             await deps.architectRestartService?.recordReplacementPromptSubmitted(context.project.repoRoot, context.taskSlug, session.id);
         }
+        if (isVcmRoleName(input.role)) {
+            await deps.roleContextRestartService?.recordPromptSubmitted(context.project.repoRoot, context.taskSlug, input.role, session.id);
+        }
         const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
             deps.jobGuard?.notePromptSubmitted({

package/dist/backend/services/role-context-restart-service.js

@@ -0,0 +1,240 @@
+import path from "node:path";
+import { VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { resolveRepoPath } from "../adapters/filesystem.js";
+import { toVcmError, VcmError } from "../errors.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+const STATE_DIR = "restart-with-context";
+export function createRoleContextRestartService(deps) {
+    const pending = new Map();
+    const operations = new Map();
+    const now = deps.now ?? (() => new Date().toISOString());
+    return {
+        async restart(repoRoot, taskSlug, role, input = {}) {
+            return withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                const current = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
+                if (!current) {
+                    throw new VcmError({
+                        code: "SESSION_MISSING",
+                        message: `${role} session has not been started.`,
+                        statusCode: 404
+                    });
+                }
+                const state = {
+                    version: 1,
+                    taskSlug,
+                    role,
+                    sourceSessionId: current.id,
+                    status: "launching",
+                    permissionMode: input.permissionMode ?? current.permissionMode,
+                    model: input.model ?? current.model,
+                    effort: input.effort ?? current.effort,
+                    cols: input.cols,
+                    rows: input.rows,
+                    updatedAt: now()
+                };
+                await persist(repoRoot, state);
+                return launch(repoRoot, state);
+            });
+        },
+        async recoverTask(repoRoot, taskSlug) {
+            for (const role of VCM_ROLE_NAMES) {
+                await withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                    const state = await load(repoRoot, taskSlug, role);
+                    if (!state) {
+                        return;
+                    }
+                    const session = await deps.sessionService.getRoleSession(repoRoot, taskSlug, role);
+                    if (state.replacementSessionId
+                        && session?.id === state.replacementSessionId
+                        && session.claudeSessionId) {
+                        await remove(repoRoot, state);
+                        return;
+                    }
+                    state.status = "launching";
+                    state.error = undefined;
+                    state.updatedAt = now();
+                    await persist(repoRoot, state);
+                    await launch(repoRoot, state);
+                });
+            }
+        },
+        async recordPromptSubmitted(repoRoot, taskSlug, role, sessionId) {
+            await withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                const state = pending.get(restartKey(repoRoot, taskSlug, role))
+                    ?? await load(repoRoot, taskSlug, role);
+                if (!state
+                    || state.status !== "awaiting_prompt_confirmation"
+                    || state.replacementSessionId !== sessionId) {
+                    return;
+                }
+                await remove(repoRoot, state);
+            });
+        },
+        async clearRole(repoRoot, taskSlug, role) {
+            await withLock(restartKey(repoRoot, taskSlug, role), async () => {
+                pending.delete(restartKey(repoRoot, taskSlug, role));
+                const target = await statePath(repoRoot, taskSlug, role);
+                if (await deps.fs.pathExists(target)) {
+                    await deps.fs.removePath?.(target, { force: true });
+                }
+            });
+        },
+        async clear(repoRoot, taskSlug) {
+            for (const role of VCM_ROLE_NAMES) {
+                pending.delete(restartKey(repoRoot, taskSlug, role));
+            }
+            const target = await stateDirectory(repoRoot, taskSlug);
+            if (await deps.fs.pathExists(target)) {
+                await deps.fs.removePath?.(target, { recursive: true, force: true });
+            }
+        }
+    };
+    async function launch(repoRoot, state) {
+        const prompts = await buildPrompts(repoRoot, state.taskSlug, state.role);
+        try {
+            const replacement = await deps.sessionService.restartRoleSessionForContext(repoRoot, state.taskSlug, state.role, {
+                permissionMode: state.permissionMode,
+                model: state.model,
+                effort: state.effort,
+                cols: state.cols,
+                rows: state.rows,
+                appendSystemPrompt: prompts.system
+            });
+            state.replacementSessionId = replacement.id;
+            state.status = "awaiting_prompt_confirmation";
+            state.updatedAt = now();
+            await persist(repoRoot, state);
+            await deps.sessionService.submitRolePrompt(repoRoot, state.taskSlug, state.role, replacement.id, prompts.user);
+            return replacement;
+        }
+        catch (error) {
+            const normalized = toVcmError(error);
+            state.status = "blocked";
+            state.error = {
+                code: normalized.code,
+                message: normalized.message
+            };
+            state.updatedAt = now();
+            await persist(repoRoot, state);
+            throw error;
+        }
+    }
+    async function buildPrompts(repoRoot, taskSlug, role) {
+        const [config, task] = await Promise.all([
+            deps.projectService.loadConfig(repoRoot),
+            deps.taskService.loadTask(repoRoot, taskSlug)
+        ]);
+        const handoffDir = task.handoffDir;
+        const stateRoot = config.stateRoot;
+        const files = roleContextFiles(role, handoffDir, stateRoot);
+        return {
+            system: [
+                `This fresh ${role} session continues the current VCM task after Restart With Context.`,
+                "",
+                "Before continuing, read the existing files or directories that apply:",
+                ...files.map((file) => `- ${file}`),
+                "- the current worktree and Git state",
+                "",
+                "Treat the current artifacts and worktree as the source of truth. Continue the accepted assignment from the recorded current state. Do not repeat completed work or rely on the previous Session transcript."
+            ].join("\n"),
+            user: `[VCM RESTART WITH CONTEXT]\nRestore the current ${role} work from the listed task artifacts and continue the accepted assignment.`
+        };
+    }
+    async function persist(repoRoot, state) {
+        await deps.fs.writeJsonAtomic(await statePath(repoRoot, state.taskSlug, state.role), state);
+        pending.set(restartKey(repoRoot, state.taskSlug, state.role), state);
+    }
+    async function load(repoRoot, taskSlug, role) {
+        const target = await statePath(repoRoot, taskSlug, role);
+        if (!(await deps.fs.pathExists(target))) {
+            return undefined;
+        }
+        const state = await deps.fs.readJson(target);
+        if (state.version !== 1
+            || state.taskSlug !== taskSlug
+            || state.role !== role
+            || !["launching", "awaiting_prompt_confirmation", "blocked"].includes(state.status)) {
+            throw new VcmError({
+                code: "ROLE_CONTEXT_RESTART_STATE_INVALID",
+                message: `Restart With Context state is invalid for ${role} in task ${taskSlug}.`,
+                statusCode: 500
+            });
+        }
+        pending.set(restartKey(repoRoot, taskSlug, role), state);
+        return state;
+    }
+    async function remove(repoRoot, state) {
+        pending.delete(restartKey(repoRoot, state.taskSlug, state.role));
+        const target = await statePath(repoRoot, state.taskSlug, state.role);
+        if (await deps.fs.pathExists(target)) {
+            await deps.fs.removePath?.(target, { force: true });
+        }
+    }
+    async function stateDirectory(repoRoot, taskSlug) {
+        const [config, task] = await Promise.all([
+            deps.projectService.loadConfig(repoRoot),
+            deps.taskService.loadTask(repoRoot, taskSlug)
+        ]);
+        return resolveRepoPath(getTaskRuntimeRepoRoot(task), path.posix.join(config.stateRoot, STATE_DIR));
+    }
+    async function statePath(repoRoot, taskSlug, role) {
+        return path.join(await stateDirectory(repoRoot, taskSlug), `${role}.json`);
+    }
+    async function withLock(key, operation) {
+        const previous = operations.get(key) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(operation);
+        operations.set(key, current);
+        try {
+            return await current;
+        }
+        finally {
+            if (operations.get(key) === current) {
+                operations.delete(key);
+            }
+        }
+    }
+}
+function roleContextFiles(role, handoffDir, stateRoot) {
+    switch (role) {
+        case "project-manager":
+            return [
+                `${handoffDir}/workflow-progress.md`,
+                `${stateRoot}/workflow/state.json`,
+                `${stateRoot}/workflow-control.json`,
+                `${handoffDir}/messages/`
+            ];
+        case "architect":
+            return [
+                `${handoffDir}/role-commands/architect.md`,
+                `${handoffDir}/architecture-brief.md`,
+                `${handoffDir}/architecture-evidence.md`,
+                `${handoffDir}/planning-progress.md`,
+                `${handoffDir}/architecture-plan.md`,
+                `${handoffDir}/architect-debug.md`,
+                `${handoffDir}/architecture-diagnosis.md`,
+                ".ai/vcm/gate-reviews/index.json"
+            ];
+        case "coder":
+            return [
+                `${handoffDir}/role-commands/coder.md`,
+                `${handoffDir}/architecture-plan.md`,
+                `${handoffDir}/coder-completion.md`,
+                ".ai/vcm/coder-workers/"
+            ];
+        case "tester":
+            return [
+                `${handoffDir}/role-commands/tester.md`,
+                `${handoffDir}/architecture-plan.md`,
+                `${handoffDir}/coder-completion.md`,
+                `${handoffDir}/test-report.md`
+            ];
+        case "reviewer":
+            return [
+                ".ai/vcm/gate-reviews/index.json",
+                ".ai/vcm/gate-reviews/requests/"
+            ];
+    }
+}
+function restartKey(repoRoot, taskSlug, role) {
+    return `${repoRoot}\0${taskSlug}\0${role}`;
+}

package/dist/backend/services/runtime-recovery-service.js

@@ -36,6 +36,7 @@ export function createRuntimeRecoveryService(deps) {
                     await recoverGateReview(taskRepoRoot, recoveredAt, context);
                     await cleanupCoderWorkers(taskRepoRoot, context);
                     await deps.architectRestartService?.recoverTask(repoRoot, task.taskSlug);
+                    await deps.roleContextRestartService?.recoverTask(repoRoot, task.taskSlug);
                     if ((roundRecovered || task.status === "running") && !hasLiveTaskSession(task.taskSlug)) {
                         await deps.taskService.updateTaskStatus(repoRoot, task.taskSlug, "stopped");
                     }

package/dist/backend/services/session-service.js

@@ -45,7 +45,7 @@ export function createSessionService(deps) {
             harnessOutdated: sessionRevision < currentRevision
         };
     }
-    async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode) {
+    async function launchRoleSession(repoRoot, taskSlug, role, input, launchMode, options = {}) {
         const config = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
@@ -145,7 +145,7 @@ export function createSessionService(deps) {
         };
         deps.registry.upsert(record);
         await persistRoleSessionRecord(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, record);
-        if (role === "project-manager") {
+        if (role === "project-manager" && options.restoreProjectManagerContext !== false) {
             await restoreProjectManagerWorkflowContext(record, taskRepoRoot, config.stateRoot);
         }
         return withHarnessRevisionView(taskRepoRoot, record);
@@ -1110,6 +1110,43 @@ export function createSessionService(deps) {
             await clearPersistedRoleSessionRecord(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, taskSlug, role, now());
             return launchRoleSession(repoRoot, taskSlug, role, input, "fresh");
         },
+        async restartRoleSessionForContext(repoRoot, taskSlug, role, input = {}) {
+            const existing = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!existing) {
+                return launchRoleSession(repoRoot, taskSlug, role, input, "fresh", {
+                    restoreProjectManagerContext: false
+                });
+            }
+            await getModelLaunchEnvironment(normalizeClaudeModel(input.model ?? existing.model));
+            if (deps.runtime.getSession(existing.id)) {
+                await deps.runtime.stop(existing.id);
+            }
+            deps.registry.remove(existing.id);
+            const config = await deps.projectService.loadConfig(repoRoot);
+            const task = await deps.taskService.loadTask(repoRoot, taskSlug);
+            await clearPersistedRoleSessionRecord(deps.fs, getTaskRuntimeRepoRoot(task), config.stateRoot, taskSlug, role, now());
+            return launchRoleSession(repoRoot, taskSlug, role, input, "fresh", {
+                restoreProjectManagerContext: false
+            });
+        },
+        async submitRolePrompt(repoRoot, taskSlug, role, expectedSessionId, prompt) {
+            const session = await this.getRoleSession(repoRoot, taskSlug, role);
+            if (!session || session.id !== expectedSessionId || session.status !== "running") {
+                throw new VcmError({
+                    code: "ROLE_SESSION_NOT_RUNNING",
+                    message: `${role} replacement session is not running.`,
+                    statusCode: 409
+                });
+            }
+            if ((await waitForSessionInputReady(session.id)) === "exited") {
+                throw new VcmError({
+                    code: "ROLE_SESSION_START_FAILED",
+                    message: `${role} replacement session exited before it could accept the recovery prompt.`,
+                    statusCode: 409
+                });
+            }
+            await submitTerminalInput(deps.runtime, session.id, prompt);
+        },
         async getRoleSession(repoRoot, taskSlug, role) {
             const config = await deps.projectService.loadConfig(repoRoot);
             const task = await deps.taskService.loadTask(repoRoot, taskSlug);

package/dist/backend/services/task-close-service.js

@@ -8,6 +8,9 @@ export function createTaskCloseService(deps) {
             if (deps.architectRestartService) {
                 await bestEffort("Unable to clear Architect restart state", () => deps.architectRestartService.clear(repoRoot, taskSlug), warnings);
             }
+            if (deps.roleContextRestartService) {
+                await bestEffort("Unable to clear Restart With Context state", () => deps.roleContextRestartService.clear(repoRoot, taskSlug), warnings);
+            }
             await stopTaskRoleSessions(repoRoot, taskSlug, warnings);
             await bestEffort("Unable to stop task translation runtime", () => deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true }), warnings);
             await bestEffort("Unable to clear task round runtime", () => deps.roundService.stopTask(taskSlug), warnings);

package/dist/backend/templates/harness/coder-agent.js

@@ -85,6 +85,7 @@ ${renderRoleMemoryRules("coder")}
 
 - In Docs-Only Flow, commit the documentation changes and submit \`.ai/vcm/handoffs/docs-update-report.md\` through \`vcm-artifact\` with the decision, changed and reviewed documents, evidence, checks, commit, and remaining documentation issues. Do not submit \`coder-completion.md\` for Docs-Only work.
 - Submit \`.ai/vcm/handoffs/coder-completion.md\` before routing back to project-manager: write a candidate outside \`.ai/vcm\`, then run \`.ai/tools/vcm-artifact coder-completion --file <candidate> --mode draft|final\`. This file is the complete, self-contained current implementation completion evidence, not a log. Each revision must restate every Scaffold Manifest disposition, changed file, helper, deviation, generated-context result, baseline-test change, L0/L1 command and result, worker result, commit, and objective failure still needed to review the current implementation without a prior revision. Replace stale content instead of appending history.
+- Maintain an incomplete \`coder-completion.md\` draft while implementation is in progress. Replace it after each completed module or worker result and after compile, L0, or L1 results so it always states completed work, remaining scaffold items, current validation, and current commits. The final submission replaces this draft.
 - After committing the actual implementation state and before submitting a final \`coder-completion.md\`, run \`.ai/tools/check-scaffold-ledger --mode completion --completion <candidate>\`; submit the candidate only after it passes. An incomplete draft does not use completion mode.
 - \`coder-completion.md\` must include \`Decision: ready_for_review | incomplete | failed\`.
 - \`coder-completion.md\` must report every Scaffold Manifest item disposition in the fixed Scaffold Completion table, plus changed files, private helpers added, manifest deviations as report-only facts, generated context status, baseline tests added or updated, L0/L1 commands and results, worker commits and integration status when workers were used, and compile/typecheck or L0/L1 failures.

package/dist/backend/templates/harness/tester-agent.js

@@ -151,6 +151,7 @@ Coverage Gap.
 ### Outputs
 
 - Write \`.ai/vcm/handoffs/test-report.md\` with \`Test Result: pass|fail|incomplete\`, evidence reviewed, tests added or updated, coverage mapping, validation progress, commands run or checked, validation results, test-infrastructure status and evidence, failed expectations, reproduction steps, skipped checks with reasons, coverage gaps, blocking validation issues, and user approval evidence.
+- Maintain an incomplete \`test-report.md\` draft while validation is in progress. Replace it after each completed validation level or long-running check and after changing tests or fixtures so it always states completed validation, remaining validation, current results, and current commits. The final submission replaces this draft.
 - \`test-report.md\` must include this test-infrastructure section:
 
 \`\`\`md