vibe-coding-master 0.7.1 → 0.7.3

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

@@ -131,27 +131,6 @@ export function registerHarnessRoutes(app, deps) {
         const taskSlug = await normalizeOptionalTaskSlug(deps, project.repoRoot, request.query.taskSlug);
         return deps.harnessFeedbackService.getState(project.repoRoot, taskSlug);
     });
-    app.post("/api/projects/harness/feedback/decision", async (request) => {
-        const project = await requireCurrentProject(deps.projectService);
-        const action = request.body?.action;
-        if (action !== "approve" && action !== "reject" && action !== "comment" && action !== "cancel") {
-            throw new VcmError({
-                code: "HARNESS_FEEDBACK_DECISION_INVALID",
-                message: "Harness feedback decision action is invalid.",
-                statusCode: 400
-            });
-        }
-        const taskSlug = await normalizeOptionalTaskSlug(deps, project.repoRoot, request.body?.taskSlug);
-        if (taskSlug && (action === "approve" || action === "comment")) {
-            const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
-            await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
-        }
-        return deps.harnessFeedbackService.decide(project.repoRoot, {
-            action,
-            taskSlug,
-            comment: typeof request.body?.comment === "string" ? request.body.comment : undefined
-        });
-    });
     app.post("/api/projects/harness/task-retrospective", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
         const trigger = request.body?.trigger === "auto" ? "auto" : "manual";

package/dist/backend/server.js

@@ -233,9 +233,8 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         sessionService,
         appSettings,
-        async isHarnessEngineerAvailable(repoRoot) {
-            const state = await harnessFeedbackService.getState(repoRoot);
-            return state.status === "idle";
+        async isHarnessEngineerAvailable() {
+            return true;
         }
     });
     const commandDispatcher = createCommandDispatcher({
@@ -347,7 +346,6 @@ export function createDefaultServerDeps(options = {}) {
         appSettings,
         runtime,
         harnessService,
-        harnessFeedbackService,
         autoMemoryService,
         gatewayService,
         jobGuard: createJobGuardService(),

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

@@ -126,7 +126,6 @@ export function createClaudeHookService(deps) {
             sessionId: session?.id,
             claudeSessionId: stringOrUndefined(input.event.session_id)
         });
-        await deps.harnessFeedbackService?.recordHarnessEngineerHook(context.project.repoRoot, eventName);
         return {
             ok: true,
             eventName,

package/dist/backend/services/harness-feedback-service.js

@@ -1,22 +1,28 @@
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { checkMarkdownArtifact, readArtifactSectionValue } from "../../shared/validation/artifact-check.js";
-import { resolveRepoPath, toRepoRelativePath } from "../adapters/filesystem.js";
+import { resolveRepoPath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 const FEEDBACK_ROOT = ".ai/vcm/harness-feedback";
 const PENDING_DIR = `${FEEDBACK_ROOT}/pending`;
-const ACTIVE_DIR = `${FEEDBACK_ROOT}/active`;
-const COMPLETED_DIR = `${FEEDBACK_ROOT}/completed`;
 const TASK_RETROSPECTIVE_DIR = `${FEEDBACK_ROOT}/task-retrospectives`;
-const STATE_PATH = `${FEEDBACK_ROOT}/state.json`;
+const LEGACY_STATE_PATH = `${FEEDBACK_ROOT}/state.json`;
 export function createHarnessFeedbackService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
-    async function getState(repoRoot, activeTaskSlug) {
-        await maybeDispatchNext(repoRoot, activeTaskSlug);
-        return buildStateReport(repoRoot);
+    async function getState(repoRoot, _activeTaskSlug) {
+        await cleanupLegacyState(repoRoot);
+        const pending = await listPendingFeedback(repoRoot);
+        return {
+            version: 1,
+            status: pending.length > 0 ? "queued" : "idle",
+            queuedCount: pending.length,
+            pending,
+            warnings: []
+        };
     }
     async function startTaskRetrospective(repoRoot, input) {
+        await cleanupLegacyState(repoRoot);
         const taskSlug = input.taskSlug.trim();
         if (!taskSlug) {
             throw new VcmError({
@@ -25,22 +31,13 @@ export function createHarnessFeedbackService(deps) {
                 statusCode: 409
             });
         }
-        const state = await loadStoredState(repoRoot);
-        if (state) {
-            throw new VcmError({
-                code: "HARNESS_FEEDBACK_ACTIVE",
-                message: "Harness feedback is already active.",
-                statusCode: 409,
-                hint: "Review, approve, comment, or reject the current Harness feedback before starting Task Harness Retrospective."
-            });
-        }
         const existingMarker = await loadTaskRetrospectiveMarker(repoRoot, taskSlug);
         if (existingMarker) {
             throw new VcmError({
                 code: "TASK_HARNESS_RETROSPECTIVE_EXISTS",
                 message: `Task Harness Retrospective has already been triggered for task: ${taskSlug}`,
                 statusCode: 409,
-                hint: "Review the existing Harness feedback item instead of starting another retrospective for the same task."
+                hint: "Review the existing retrospective result instead of starting another retrospective for the same task."
             });
         }
         const finalAcceptancePath = path.posix.join(input.handoffDir, "final-acceptance.md");
@@ -62,204 +59,39 @@ export function createHarnessFeedbackService(deps) {
         }
         const session = await ensureIdleHarnessEngineer(repoRoot, taskSlug);
         const timestamp = now();
-        const finalAcceptanceHash = `sha256:${sha256(finalAcceptanceContent)}`;
-        const id = sanitizeFeedbackId(`${timestamp}-task-retrospective-${taskSlug}`);
-        const feedbackPath = `${ACTIVE_DIR}/${id}/feedback.md`;
-        const analysisPath = `${ACTIVE_DIR}/${id}/analysis.md`;
-        const applyReportPath = `${ACTIVE_DIR}/${id}/apply-report.md`;
-        const active = {
-            id,
-            title: `Task Harness Retrospective: ${taskSlug}`,
-            path: feedbackPath,
-            source: "task-retrospective",
+        const analysisPath = `${TASK_RETROSPECTIVE_DIR}/${sanitizeFeedbackId(taskSlug)}.md`;
+        await persistTaskRetrospectiveMarker(repoRoot, {
+            version: 1,
             taskSlug,
-            summary: "Review the completed task workflow for reusable harness problems.",
             trigger: input.trigger,
-            finalAcceptanceHash,
-            feedbackPath,
+            status: "triggered",
             analysisPath,
-            applyReportPath,
-            startedAt: timestamp,
-            updatedAt: timestamp,
-            lastPromptAt: timestamp
-        };
-        const nextState = {
-            version: 1,
-            status: "analyzing",
-            active
-        };
-        await deps.fs.ensureDir(resolveRepoPath(repoRoot, path.posix.dirname(feedbackPath)));
-        await deps.fs.writeText(resolveRepoPath(repoRoot, feedbackPath), renderTaskRetrospectiveFeedback(active, finalAcceptancePath));
-        await persistStoredState(repoRoot, nextState);
-        await persistTaskRetrospectiveMarker(repoRoot, active, "analyzing");
-        await submitTerminalInput(deps.runtime, session.id, buildTaskRetrospectivePrompt(repoRoot, active));
-        return buildStateReport(repoRoot);
-    }
-    async function decide(repoRoot, input) {
-        const state = await loadStoredState(repoRoot);
-        if (state && input.action === "cancel") {
-            await completeActive(repoRoot, state, "canceled", input.comment);
-            await clearStoredState(repoRoot);
-            return getState(repoRoot, input.taskSlug);
-        }
-        if (!state || state.status !== "awaiting_user_approval") {
-            throw new VcmError({
-                code: "HARNESS_FEEDBACK_NOT_AWAITING_APPROVAL",
-                message: "There is no Harness feedback waiting for user approval.",
-                statusCode: 409
-            });
-        }
-        if (input.action === "reject") {
-            await completeActive(repoRoot, state, "rejected", input.comment);
-            await clearStoredState(repoRoot);
-            return getState(repoRoot, input.taskSlug);
-        }
-        const taskSlug = input.taskSlug?.trim();
-        if (!taskSlug) {
-            throw new VcmError({
-                code: "HARNESS_FEEDBACK_TASK_REQUIRED",
-                message: "Select an active task before asking Harness Engineer to continue feedback work.",
-                statusCode: 409
-            });
-        }
-        if (input.action === "comment") {
-            const session = await ensureIdleHarnessEngineer(repoRoot, taskSlug);
-            const timestamp = now();
-            const nextState = {
-                ...state,
-                status: "analyzing",
-                active: {
-                    ...state.active,
-                    updatedAt: timestamp,
-                    lastPromptAt: timestamp
-                }
-            };
-            await persistStoredState(repoRoot, nextState);
-            await persistTaskRetrospectiveMarker(repoRoot, nextState.active, "analyzing");
-            await submitTerminalInput(deps.runtime, session.id, buildFeedbackCommentPrompt(repoRoot, nextState.active, input.comment ?? ""));
-            return buildStateReport(repoRoot);
-        }
-        const session = await ensureIdleHarnessEngineer(repoRoot, taskSlug);
-        const timestamp = now();
-        const nextState = {
-            ...state,
-            status: "applying",
-            active: {
-                ...state.active,
-                updatedAt: timestamp,
-                lastPromptAt: timestamp
-            }
-        };
-        await persistStoredState(repoRoot, nextState);
-        await persistTaskRetrospectiveMarker(repoRoot, nextState.active, "applying");
-        await submitTerminalInput(deps.runtime, session.id, buildFeedbackApplyPrompt(repoRoot, nextState.active, input.comment ?? ""));
-        return buildStateReport(repoRoot);
-    }
-    async function recordHarnessEngineerHook(repoRoot, eventName) {
-        if (eventName !== "Stop" && eventName !== "StopFailure") {
-            return;
-        }
-        const state = await loadStoredState(repoRoot);
-        if (!state) {
-            return;
-        }
-        const timestamp = now();
-        if (state.status === "analyzing") {
-            const nextState = {
-                ...state,
-                status: "awaiting_user_approval",
-                active: {
-                    ...state.active,
-                    updatedAt: timestamp
-                }
-            };
-            await persistStoredState(repoRoot, nextState);
-            await persistTaskRetrospectiveMarker(repoRoot, nextState.active, "awaiting_user_approval", timestamp);
-            return;
-        }
-        if (state.status === "applying") {
-            await completeActive(repoRoot, {
-                ...state,
-                active: {
-                    ...state.active,
-                    updatedAt: timestamp
-                }
-            }, "applied");
-            await clearStoredState(repoRoot);
-        }
-    }
-    async function assertHarnessEngineerAvailable(repoRoot) {
-        const state = await loadStoredState(repoRoot);
-        if (!state) {
-            return;
-        }
-        throw new VcmError({
-            code: "HARNESS_ENGINEER_FEEDBACK_ACTIVE",
-            message: "Harness Engineer is reserved for an active Harness feedback item.",
-            statusCode: 409,
-            hint: state.status === "awaiting_user_approval"
-                ? "Review, approve, comment, or reject the current Harness feedback before starting another Harness Engineer task."
-                : "Wait for the current Harness feedback turn to finish before starting another Harness Engineer task."
+            finalAcceptanceHash: `sha256:${sha256(finalAcceptanceContent)}`,
+            createdAt: timestamp,
+            updatedAt: timestamp
         });
+        await submitTerminalInput(deps.runtime, session.id, buildTaskRetrospectivePrompt(repoRoot, analysisPath));
+        return getState(repoRoot);
     }
-    async function maybeDispatchNext(repoRoot, activeTaskSlug) {
-        const state = await loadStoredState(repoRoot);
-        if (state) {
-            return;
-        }
-        const pending = await listPendingFeedback(repoRoot);
-        const next = pending[0];
-        const taskSlug = activeTaskSlug?.trim();
-        if (!next || !taskSlug) {
-            return;
-        }
-        const session = await getIdleHarnessEngineer(repoRoot, taskSlug);
-        if (!session) {
-            return;
-        }
-        const timestamp = now();
-        const analysisPath = `${ACTIVE_DIR}/${next.id}/analysis.md`;
-        const applyReportPath = `${ACTIVE_DIR}/${next.id}/apply-report.md`;
-        const active = {
-            ...next,
-            feedbackPath: next.path,
-            source: next.source ?? "role-feedback",
-            analysisPath,
-            applyReportPath,
-            startedAt: timestamp,
-            updatedAt: timestamp,
-            lastPromptAt: timestamp
-        };
-        const nextState = {
-            version: 1,
-            status: "analyzing",
-            active
-        };
-        await persistStoredState(repoRoot, nextState);
-        await deps.fs.ensureDir(resolveRepoPath(repoRoot, path.posix.dirname(analysisPath)));
-        await submitTerminalInput(deps.runtime, session.id, await buildFeedbackAnalysisPrompt(repoRoot, active));
+    async function assertHarnessEngineerAvailable(_repoRoot) {
+        return undefined;
     }
-    async function getIdleHarnessEngineer(repoRoot, taskSlug) {
+    async function ensureIdleHarnessEngineer(repoRoot, taskSlug) {
         const existing = await deps.sessionService.getProjectHarnessEngineerSession(repoRoot);
         if (existing?.status === "running" && existing.activityStatus === "running") {
-            return undefined;
+            throw new VcmError({
+                code: "HARNESS_ENGINEER_BUSY",
+                message: "Harness Engineer is busy or unavailable.",
+                statusCode: 409,
+                hint: "Wait for the current Harness Engineer turn to finish, then retry."
+            });
         }
         const session = await deps.sessionService.ensureProjectHarnessEngineerSession(repoRoot, {
             taskSlug,
             cols: 120,
             rows: 32
         });
-        if (session.status !== "running" || session.activityStatus === "running") {
-            return undefined;
-        }
-        if (!deps.runtime.getSession(session.id)) {
-            return undefined;
-        }
-        return session;
-    }
-    async function ensureIdleHarnessEngineer(repoRoot, taskSlug) {
-        const session = await getIdleHarnessEngineer(repoRoot, taskSlug);
-        if (!session) {
+        if (session.status !== "running" || session.activityStatus === "running" || !deps.runtime.getSession(session.id)) {
             throw new VcmError({
                 code: "HARNESS_ENGINEER_BUSY",
                 message: "Harness Engineer is busy or unavailable.",
@@ -269,54 +101,6 @@ export function createHarnessFeedbackService(deps) {
         }
         return session;
     }
-    async function buildStateReport(repoRoot) {
-        const [state, pending] = await Promise.all([
-            loadStoredState(repoRoot),
-            listPendingFeedback(repoRoot)
-        ]);
-        if (!state) {
-            return {
-                version: 1,
-                status: pending.length > 0 ? "queued" : "idle",
-                queuedCount: pending.length,
-                pending,
-                warnings: []
-            };
-        }
-        const active = await readActiveItem(repoRoot, state);
-        return {
-            version: 1,
-            status: state.status,
-            queuedCount: Math.max(0, pending.length - (pending.some((item) => item.id === state.active.id) ? 1 : 0)),
-            pending: pending.filter((item) => item.id !== state.active.id),
-            active,
-            warnings: []
-        };
-    }
-    async function readActiveItem(repoRoot, state) {
-        const feedbackContent = await readOptionalText(repoRoot, state.active.feedbackPath) ?? "";
-        const analysisContent = await readOptionalText(repoRoot, state.active.analysisPath);
-        const applyReportContent = await readOptionalText(repoRoot, state.active.applyReportPath);
-        return {
-            id: state.active.id,
-            title: state.active.title,
-            path: state.active.path,
-            source: state.active.source,
-            reporterRole: state.active.reporterRole,
-            taskSlug: state.active.taskSlug,
-            summary: state.active.summary,
-            status: state.status,
-            startedAt: state.active.startedAt,
-            updatedAt: state.active.updatedAt,
-            trigger: state.active.trigger,
-            finalAcceptanceHash: state.active.finalAcceptanceHash,
-            feedbackContent,
-            analysisPath: state.active.analysisPath,
-            analysisContent,
-            applyReportPath: state.active.applyReportPath,
-            applyReportContent
-        };
-    }
     async function listPendingFeedback(repoRoot) {
         const pendingDir = resolveRepoPath(repoRoot, PENDING_DIR);
         if (!(await deps.fs.pathExists(pendingDir))) {
@@ -350,135 +134,37 @@ export function createHarnessFeedbackService(deps) {
             summary: metadata.summary
         };
     }
-    async function buildFeedbackAnalysisPrompt(repoRoot, active) {
-        const feedback = await readOptionalText(repoRoot, active.feedbackPath) ?? "";
-        return [
-            "[VCM Harness Feedback Analysis]",
-            "",
-            "Analyze this harness feedback. Do not edit files yet.",
-            "",
-            `Base repository root: ${repoRoot}`,
-            `Feedback file: ${resolveRepoPath(repoRoot, active.feedbackPath)}`,
-            `Result path: ${resolveRepoPath(repoRoot, active.analysisPath)}`,
-            "",
-            "Rules:",
-            "- Decide whether the reported issue is a real reusable harness problem.",
-            "- Inspect relevant harness files before judging.",
-            "- If the issue is not real or does not need a harness change, say so in the result file.",
-            "- If it should be fixed, write a short proposal with affected files, proposed diff shape, risks, validation, and whether a VCM GitHub issue is needed.",
-            "- Do not edit harness files or product source during this analysis turn.",
-            "- End your turn after writing the result file.",
-            "",
-            "<HARNESS_FEEDBACK>",
-            feedback.trimEnd(),
-            "</HARNESS_FEEDBACK>"
-        ].join("\n");
-    }
-    function buildTaskRetrospectivePrompt(repoRoot, active) {
+    function buildTaskRetrospectivePrompt(repoRoot, analysisPath) {
         return [
             "[VCM Task Harness Retrospective]",
             "",
             "Review the completed task from the current active task worktree.",
             "",
-            `Write the analysis to Result Path: ${resolveRepoPath(repoRoot, active.analysisPath)}`,
+            `Write the analysis to Result Path: ${resolveRepoPath(repoRoot, analysisPath)}`,
             "End your turn after writing the result."
         ].join("\n");
     }
-    function buildFeedbackCommentPrompt(repoRoot, active, comment) {
-        return [
-            "[VCM Harness Feedback Revision]",
-            "",
-            "The user reviewed your harness feedback analysis and added comments.",
-            "",
-            `Feedback file: ${resolveRepoPath(repoRoot, active.feedbackPath)}`,
-            `Current analysis path: ${resolveRepoPath(repoRoot, active.analysisPath)}`,
-            `Rewrite the analysis result at: ${resolveRepoPath(repoRoot, active.analysisPath)}`,
-            "",
-            "Rules:",
-            "- Do not edit harness files yet.",
-            "- Address the user's comments and keep the proposal concise.",
-            "- End your turn after updating the analysis result file.",
-            "",
-            "<USER_COMMENT>",
-            comment.trim(),
-            "</USER_COMMENT>"
-        ].join("\n");
-    }
-    function buildFeedbackApplyPrompt(repoRoot, active, comment) {
-        return [
-            "[VCM Harness Feedback Approved]",
-            "",
-            "The user approved this harness improvement. Apply only the approved harness changes.",
-            "",
-            `Base repository root: ${repoRoot}`,
-            `Feedback file: ${resolveRepoPath(repoRoot, active.feedbackPath)}`,
-            `Approved analysis path: ${resolveRepoPath(repoRoot, active.analysisPath)}`,
-            `Write completion report to: ${resolveRepoPath(repoRoot, active.applyReportPath)}`,
-            "",
-            "Rules:",
-            "- Work in the active task worktree.",
-            "- Edit only harness files and project harness docs that are necessary for the approved change.",
-            "- Do not edit product source code.",
-            "- Do not overwrite VCM fixed managed blocks; draft an issue instead if a fixed template is wrong.",
-            "- Stage the harness changes and create a commit yourself.",
-            "- Write the completion report with files changed, commit id if available, validation run, and any follow-up.",
-            "- End your turn after the report is written.",
-            ...(comment.trim()
-                ? ["", "<USER_APPROVAL_COMMENT>", comment.trim(), "</USER_APPROVAL_COMMENT>"]
-                : [])
-        ].join("\n");
-    }
-    async function completeActive(repoRoot, state, outcome, comment = "") {
-        const completedDir = `${COMPLETED_DIR}/${state.active.id}`;
-        await deps.fs.ensureDir(resolveRepoPath(repoRoot, completedDir));
-        const feedbackContent = await readOptionalText(repoRoot, state.active.feedbackPath);
-        const analysisContent = await readOptionalText(repoRoot, state.active.analysisPath);
-        const applyReportContent = await readOptionalText(repoRoot, state.active.applyReportPath);
-        if (feedbackContent !== undefined) {
-            await deps.fs.writeText(resolveRepoPath(repoRoot, `${completedDir}/feedback.md`), feedbackContent);
-        }
-        if (analysisContent !== undefined) {
-            await deps.fs.writeText(resolveRepoPath(repoRoot, `${completedDir}/analysis.md`), analysisContent);
-        }
-        if (applyReportContent !== undefined) {
-            await deps.fs.writeText(resolveRepoPath(repoRoot, `${completedDir}/apply-report.md`), applyReportContent);
-        }
-        await deps.fs.writeJsonAtomic(resolveRepoPath(repoRoot, `${completedDir}/decision.json`), {
-            version: 1,
-            id: state.active.id,
-            title: state.active.title,
-            outcome,
-            comment,
-            completedAt: now()
-        });
-        await persistTaskRetrospectiveMarker(repoRoot, state.active, outcome === "applied" ? "completed" : outcome);
-        await deps.fs.removePath?.(resolveRepoPath(repoRoot, state.active.feedbackPath), { force: true });
-        await deps.fs.removePath?.(resolveRepoPath(repoRoot, path.posix.dirname(state.active.analysisPath)), { recursive: true, force: true });
-    }
-    async function loadStoredState(repoRoot) {
-        const statePath = resolveRepoPath(repoRoot, STATE_PATH);
-        if (!(await deps.fs.pathExists(statePath))) {
-            return undefined;
-        }
-        const state = await deps.fs.readJson(statePath);
-        if (state?.version !== 1 || !state.active?.id || !state.status) {
+    async function loadTaskRetrospectiveMarker(repoRoot, taskSlug) {
+        const markerPath = resolveRepoPath(repoRoot, getTaskRetrospectiveMarkerPath(taskSlug));
+        if (!(await deps.fs.pathExists(markerPath))) {
             return undefined;
         }
-        state.active.source = state.active.source ?? "role-feedback";
-        return state;
+        return deps.fs.readJson(markerPath);
     }
-    async function persistStoredState(repoRoot, state) {
-        await deps.fs.writeJsonAtomic(resolveRepoPath(repoRoot, STATE_PATH), state);
+    async function persistTaskRetrospectiveMarker(repoRoot, marker) {
+        const markerPath = resolveRepoPath(repoRoot, getTaskRetrospectiveMarkerPath(String(marker.taskSlug ?? "")));
+        await deps.fs.ensureDir(path.dirname(markerPath));
+        await deps.fs.writeJsonAtomic(markerPath, marker);
     }
-    async function clearStoredState(repoRoot) {
-        await deps.fs.removePath?.(resolveRepoPath(repoRoot, STATE_PATH), { force: true });
+    async function cleanupLegacyState(repoRoot) {
+        const statePath = resolveRepoPath(repoRoot, LEGACY_STATE_PATH);
+        if (await deps.fs.pathExists(statePath)) {
+            await deps.fs.removePath?.(statePath, { force: true });
+        }
     }
     async function readOptionalText(repoRoot, relativePath) {
         const absolutePath = resolveRepoPath(repoRoot, relativePath);
-        if (!(await deps.fs.pathExists(absolutePath))) {
-            return undefined;
-        }
-        return deps.fs.readText(absolutePath);
+        return readAbsoluteOptionalText(absolutePath);
     }
     async function readAbsoluteOptionalText(absolutePath) {
         if (!(await deps.fs.pathExists(absolutePath))) {
@@ -486,34 +172,9 @@ export function createHarnessFeedbackService(deps) {
         }
         return deps.fs.readText(absolutePath);
     }
-    async function loadTaskRetrospectiveMarker(repoRoot, taskSlug) {
-        const markerPath = resolveRepoPath(repoRoot, getTaskRetrospectiveMarkerPath(taskSlug));
-        if (!(await deps.fs.pathExists(markerPath))) {
-            return undefined;
-        }
-        return deps.fs.readJson(markerPath);
-    }
-    async function persistTaskRetrospectiveMarker(repoRoot, active, status, timestamp = now()) {
-        if (active.source !== "task-retrospective" || !active.taskSlug) {
-            return;
-        }
-        await deps.fs.writeJsonAtomic(resolveRepoPath(repoRoot, getTaskRetrospectiveMarkerPath(active.taskSlug)), {
-            version: 1,
-            taskSlug: active.taskSlug,
-            activeId: active.id,
-            trigger: active.trigger ?? "manual",
-            status,
-            finalAcceptanceHash: active.finalAcceptanceHash,
-            createdAt: active.startedAt,
-            updatedAt: timestamp,
-            ...(status === "completed" || status === "rejected" ? { completedAt: timestamp } : {})
-        });
-    }
     return {
         getState,
         startTaskRetrospective,
-        decide,
-        recordHarnessEngineerHook,
         assertHarnessEngineerAvailable
     };
 }
@@ -535,19 +196,6 @@ function firstHeading(content) {
 function compactLine(value) {
     return value.replace(/\s+/g, " ").trim().slice(0, 160);
 }
-function renderTaskRetrospectiveFeedback(active, finalAcceptancePath) {
-    return [
-        `# ${active.title}`,
-        "",
-        `Source: ${active.source}`,
-        `Task slug: ${active.taskSlug ?? ""}`,
-        `Trigger: ${active.trigger ?? "manual"}`,
-        `Final acceptance: ${finalAcceptancePath}`,
-        `Final acceptance hash: ${active.finalAcceptanceHash ?? ""}`,
-        "",
-        "Summary: Review the completed task workflow for reusable harness problems."
-    ].join("\n");
-}
 function getTaskRetrospectiveMarkerPath(taskSlug) {
     return `${TASK_RETROSPECTIVE_DIR}/${sanitizeFeedbackId(taskSlug)}.json`;
 }
@@ -558,6 +206,3 @@ function sanitizeFeedbackId(value) {
 function sha256(content) {
     return createHash("sha256").update(content).digest("hex");
 }
-export function getHarnessFeedbackRelativePath(repoRoot, absolutePath) {
-    return toRepoRelativePath(repoRoot, absolutePath);
-}

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

@@ -6,7 +6,6 @@ const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
 const BOOTSTRAP_SESSION_PATH = ".ai/vcm/bootstrap/session.json";
 const HARNESS_FEEDBACK_STATE_PATH = ".ai/vcm/harness-feedback/state.json";
 const CODER_WORKERS_RUNTIME_DIR = ".ai/vcm/coder-workers";
-const RECOVERABLE_FEEDBACK_STATES = new Set(["analyzing", "applying"]);
 export function createRuntimeRecoveryService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
     return {
@@ -20,7 +19,7 @@ export function createRuntimeRecoveryService(deps) {
             const config = await deps.projectService.loadConfig(repoRoot);
             await runStep(context, "recover project tool sessions", () => recoverProjectToolSessions(repoRoot, recoveredAt, context));
             await runStep(context, "recover harness bootstrap", () => recoverHarnessBootstrap(repoRoot, recoveredAt, context));
-            await runStep(context, "recover harness feedback", () => recoverHarnessFeedback(repoRoot, recoveredAt, context));
+            await runStep(context, "cleanup legacy harness feedback state", () => cleanupLegacyHarnessFeedback(repoRoot, context));
             const tasks = await deps.taskService.listTasks(repoRoot);
             for (const task of tasks.filter((candidate) => candidate.cleanupStatus === "cleaned")) {
                 await runStep(context, `retry cleaned task ${task.taskSlug}`, async () => {
@@ -258,39 +257,13 @@ export function createRuntimeRecoveryService(deps) {
         await deps.fs.removePath?.(absolutePath, { force: true });
         context.changedPaths.add(BOOTSTRAP_SESSION_PATH);
     }
-    async function recoverHarnessFeedback(repoRoot, timestamp, context) {
+    async function cleanupLegacyHarnessFeedback(repoRoot, context) {
         const absolutePath = path.join(repoRoot, HARNESS_FEEDBACK_STATE_PATH);
-        const state = await readJsonIfExists(absolutePath);
-        if (!state?.status || !RECOVERABLE_FEEDBACK_STATES.has(state.status)) {
+        if (!(await deps.fs.pathExists(absolutePath))) {
             return;
         }
-        const previousStatus = state.status;
-        const next = {
-            ...state,
-            status: "awaiting_user_approval",
-            updatedAt: timestamp,
-            active: state.active
-                ? {
-                    ...state.active,
-                    updatedAt: timestamp
-                }
-                : state.active
-        };
-        await deps.fs.writeJsonAtomic(absolutePath, next);
+        await deps.fs.removePath?.(absolutePath, { force: true });
         context.changedPaths.add(HARNESS_FEEDBACK_STATE_PATH);
-        const analysisPath = state.active?.analysisPath;
-        if (analysisPath) {
-            const notePath = path.join(repoRoot, analysisPath);
-            if (!(await deps.fs.pathExists(notePath))) {
-                await deps.fs.writeText(notePath, [
-                    "# Harness Feedback Recovery",
-                    "",
-                    `VCM restarted while this harness feedback item was ${previousStatus}.`,
-                    "Review the current repository diff and either comment, reject, cancel, or approve explicitly."
-                ].join("\n"));
-                context.changedPaths.add(analysisPath);
-            }
-        }
     }
     function hasLiveTaskSession(taskSlug) {
         return deps.runtime.listSessions(taskSlug).some((session) => session.status === "running");