vibe-coding-master 0.4.19 → 0.4.20

package/dist/backend/adapters/git-adapter.js

@@ -201,6 +201,21 @@ export function createGitAdapter(runner) {
                 hint: result.stderr
             });
         },
+        async mergeBranchFastForward(repoRoot, branch) {
+            const result = await runGit(runner, repoRoot, ["merge", "--ff-only", branch]);
+            if (result.exitCode !== 0) {
+                throw new VcmError({
+                    code: "GIT_MERGE_FAILED",
+                    message: `Unable to fast-forward merge branch: ${branch}`,
+                    statusCode: 409,
+                    hint: result.stderr || result.stdout || "Rebase the task branch onto the connected repository branch, then try again."
+                });
+            }
+            return {
+                stdout: result.stdout,
+                stderr: result.stderr
+            };
+        },
         async addPaths(repoRoot, paths) {
             if (paths.length === 0) {
                 return;

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

@@ -38,6 +38,13 @@ export function registerHarnessRoutes(app, deps) {
             commitSha: request.query.commit
         });
     });
+    app.post("/api/projects/harness/repository-diff/merge-to-current-branch", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.harnessService.mergeRepositoryDiffToCurrentBranch(project.repoRoot, {
+            taskRepoRoot: task.worktreePath,
+            taskBranch: task.branch
+        });
+    });
     app.get("/api/projects/harness/bootstrap", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
         try {
@@ -119,6 +126,16 @@ export function registerHarnessRoutes(app, deps) {
             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";
+        return deps.harnessFeedbackService.startTaskRetrospective(project.repoRoot, {
+            taskSlug: task.taskSlug,
+            taskRepoRoot: task.worktreePath,
+            handoffDir: task.handoffDir,
+            trigger
+        });
+    });
 }
 function degradedHarnessStatus(error) {
     return {

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

@@ -1,4 +1,4 @@
-import { CORE_VCM_ROLE_NAMES, DISPATCHABLE_ROLES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES, VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { isOpenFileLimitError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTaskRoutes(app, deps) {
@@ -41,7 +41,7 @@ export function registerTaskRoutes(app, deps) {
 async function stopRunningRoleSessions(deps, repoRoot, taskSlug) {
     const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
     for (const session of sessions) {
-        if (session.status === "running" && CORE_VCM_ROLE_NAMES.some((role) => role === session.role)) {
+        if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
             await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
         }
     }

package/dist/backend/gateway/gateway-service.js

@@ -1,5 +1,5 @@
 import { readFile } from "node:fs/promises";
-import { CORE_VCM_ROLE_DEFINITIONS, CORE_VCM_ROLE_NAMES, GATE_REVIEWER_ROLE_DEFINITION } from "../../shared/constants.js";
+import { CORE_VCM_ROLE_DEFINITIONS, GATE_REVIEWER_ROLE_DEFINITION, VCM_ROLE_NAMES } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
@@ -425,9 +425,6 @@ export function createGatewayService(deps) {
                 };
                 const existing = await deps.sessionService.getRoleSession(project.repoRoot, task.taskSlug, definition.name);
                 if (existing?.status === "running") {
-                    if (definition.name === "gate-reviewer") {
-                        await deps.sessionService.resumeRoleSession(project.repoRoot, task.taskSlug, definition.name, sessionInput);
-                    }
                     startedRoles.push(definition.name);
                     continue;
                 }
@@ -556,7 +553,7 @@ export function createGatewayService(deps) {
     async function stopRunningRoleSessions(repoRoot, taskSlug) {
         const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
         for (const session of sessions) {
-            if (session.status === "running" && CORE_VCM_ROLE_NAMES.some((role) => role === session.role)) {
+            if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
                 await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
             }
         }

package/dist/backend/services/app-settings-service.js

@@ -230,7 +230,9 @@ function normalizePreferences(input) {
     return {
         themeMode: normalizeThemeMode(candidate.themeMode),
         flowPauseAlerts: rawFlowPauseAlerts !== false,
+        roleRetryEnabled: candidate.roleRetryEnabled !== false,
         permissionRequestMode: normalizePermissionRequestMode(candidate.permissionRequestMode),
+        autoTaskHarnessReviewEnabled: candidate.autoTaskHarnessReviewEnabled === true,
         translationEnabled: candidate.translationEnabled === true,
         translationAutoSendEnabled: candidate.translationAutoSendEnabled === true,
         translationTargetLanguage: normalizeTranslationTargetLanguage(candidate.translationTargetLanguage),

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

@@ -2,9 +2,22 @@ import { isGateReviewerRoleName, isHarnessEngineerToolRoleName, isTranslatorTool
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
-const MAX_STOP_FAILURE_RECOVERY_ATTEMPTS = 2;
+const MAX_ROLE_RETRY_ATTEMPTS = 20;
+const ROLE_RETRY_BASE_DELAY_MS = 60_000;
+const NON_RETRYABLE_STOP_FAILURE_ERRORS = new Set([
+    "authentication_failed",
+    "oauth_org_not_allowed",
+    "billing_error",
+    "invalid_request",
+    "model_not_found",
+    "max_output_tokens"
+]);
+const DIAGNOSTIC_SNIPPET_MAX_LENGTH = 2000;
 export function createClaudeHookService(deps) {
-    const stopFailureRecoveryAttempts = new Map();
+    const stopFailureRetryTimers = new Map();
+    const now = deps.now ?? (() => new Date().toISOString());
+    const retrySetTimeout = deps.retrySetTimeout ?? ((callback, delayMs) => globalThis.setTimeout(callback, delayMs));
+    const retryClearTimeout = deps.retryClearTimeout ?? ((timer) => globalThis.clearTimeout(timer));
     async function getHookContext(input) {
         if (!isVcmRoleName(input.role)) {
             throw new VcmError({
@@ -99,19 +112,8 @@ export function createClaudeHookService(deps) {
         };
     }
     async function resolveHookTaskSlug(repoRoot, input) {
-        if (!isGateReviewerRoleName(input.role)) {
-            return input.taskSlug;
-        }
-        const session = await deps.sessionService.getProjectGateReviewerSession(repoRoot);
-        if (session?.activeTaskSlug) {
-            return session.activeTaskSlug;
-        }
-        throw new VcmError({
-            code: "GATE_REVIEWER_TASK_UNBOUND",
-            message: "Gate Reviewer hook arrived without an active task binding.",
-            statusCode: 409,
-            hint: "Start or resume Gate Reviewer from the current task before submitting work."
-        });
+        void repoRoot;
+        return input.taskSlug;
     }
     async function handleUserPromptSubmitHook(input) {
         const eventName = parseHookEvent(input.event.hook_event_name);
@@ -177,7 +179,7 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
-        clearStopFailureRecovery(context.project.repoRoot, context.taskSlug, input.role);
+        await clearStopFailureRecoveryState(context, input.role);
         if (options.allowBlock && deps.jobGuard) {
             const verdict = await deps.jobGuard.evaluateStop({
                 repoRoot: context.project.repoRoot,
@@ -215,15 +217,24 @@ export function createClaudeHookService(deps) {
         const pending = await deps.messageService.listPendingRouteFiles(routeDispatchInput);
         const hasCompletionEvidence = pending.some((routeFile) => routeFile.fromRole === input.role);
         if (hasCompletionEvidence) {
-            clearStopFailureRecovery(context.project.repoRoot, context.taskSlug, input.role);
+            await clearStopFailureRecoveryState(context, input.role);
             return recordTurnEnd(input, context, eventName, {
                 dispatchRouteFiles: !isGateReviewerRoleName(input.role),
                 notifyGateway: false,
                 settleGuard: true
             });
         }
-        const recovered = await dispatchStopFailureRecovery(input, context);
-        if (recovered) {
+        const failure = parseStopFailureDiagnostic(input.event);
+        if (!failure.retryable) {
+            await markStopFailureRecoveryFailed(input, context, failure, 0);
+            return recordTurnEnd(input, context, eventName, {
+                dispatchRouteFiles: false,
+                notifyGateway: false,
+                settleGuard: false
+            });
+        }
+        const retryScheduled = await scheduleStopFailureRetry(input, context, failure);
+        if (retryScheduled) {
             return {
                 ok: true,
                 eventName,
@@ -336,38 +347,147 @@ export function createClaudeHookService(deps) {
             ...(stoppedRole ? { stoppedRole } : {})
         };
     }
-    async function dispatchStopFailureRecovery(input, context) {
-        if (!deps.runtime) {
+    async function scheduleStopFailureRetry(input, context, failure) {
+        const preferences = await deps.appSettings.getPreferences();
+        if (!preferences.roleRetryEnabled || !deps.runtime) {
             return false;
         }
-        const key = stopFailureRecoveryKey(context.project.repoRoot, context.taskSlug, input.role);
-        const attempt = (stopFailureRecoveryAttempts.get(key) ?? 0) + 1;
-        if (attempt > MAX_STOP_FAILURE_RECOVERY_ATTEMPTS) {
+        const stateInput = createRoundStateInput(context);
+        const currentRoundState = await deps.roundService.getSessionRoundState(stateInput);
+        const previousAttempt = currentRoundState.roleRecovery?.role === input.role &&
+            currentRoundState.roleRecovery.status !== "failed"
+            ? currentRoundState.roleRecovery.attempt
+            : 0;
+        const attempt = previousAttempt + 1;
+        const timestamp = now();
+        if (attempt > MAX_ROLE_RETRY_ATTEMPTS) {
+            clearStopFailureRetryTimer(context.project.repoRoot, context.taskSlug, input.role);
+            await markStopFailureRecoveryFailed(input, context, failure, MAX_ROLE_RETRY_ATTEMPTS, timestamp);
             return false;
         }
+        const nextRetryAt = new Date(Date.parse(timestamp) + attempt * ROLE_RETRY_BASE_DELAY_MS).toISOString();
+        await deps.roundService.setRoleRecovery({
+            ...stateInput,
+            recovery: {
+                role: input.role,
+                status: "waiting",
+                attempt,
+                maxAttempts: MAX_ROLE_RETRY_ATTEMPTS,
+                lastFailureAt: timestamp,
+                error: failure.error,
+                errorDetails: failure.errorDetails,
+                lastAssistantMessage: failure.lastAssistantMessage,
+                retryable: failure.retryable,
+                nextRetryAt
+            }
+        });
+        await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
+        scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt);
+        return true;
+    }
+    function scheduleStopFailureRetryTimer(input, context, attempt, nextRetryAt) {
+        const key = stopFailureRecoveryKey(context.project.repoRoot, context.taskSlug, input.role);
+        clearStopFailureRetryTimer(context.project.repoRoot, context.taskSlug, input.role);
+        const delayMs = Math.max(0, Date.parse(nextRetryAt) - Date.parse(now()));
+        const timer = retrySetTimeout(() => {
+            stopFailureRetryTimers.delete(key);
+            void runScheduledStopFailureRetry(input, context, attempt).catch(() => undefined);
+        }, delayMs);
+        stopFailureRetryTimers.set(key, timer);
+    }
+    async function runScheduledStopFailureRetry(input, context, attempt) {
+        const stateInput = createRoundStateInput(context);
+        const currentRoundState = await deps.roundService.getSessionRoundState(stateInput);
+        const recovery = currentRoundState.roleRecovery;
+        if (!recovery || recovery.role !== input.role || recovery.attempt !== attempt || recovery.status !== "waiting") {
+            return;
+        }
+        const timestamp = now();
         const session = await deps.sessionService.getRoleSession(context.project.repoRoot, context.taskSlug, input.role);
-        if (!session || session.status !== "running") {
-            return false;
+        if (!session || session.status !== "running" || !deps.runtime) {
+            await deps.roundService.setRoleRecovery({
+                ...stateInput,
+                recovery: {
+                    ...recovery,
+                    status: "failed",
+                    failedAt: timestamp
+                }
+            });
+            await recordTurnEnd(input, context, "StopFailure", {
+                dispatchRouteFiles: false,
+                notifyGateway: false,
+                settleGuard: false
+            });
+            return;
         }
-        stopFailureRecoveryAttempts.set(key, attempt);
-        await submitTerminalInput(deps.runtime, session.id, renderStopFailureRecoveryPrompt(attempt));
+        await deps.roundService.setRoleRecovery({
+            ...stateInput,
+            recovery: {
+                ...recovery,
+                status: "retrying",
+                nextRetryAt: undefined,
+                lastRetryAt: timestamp
+            }
+        });
+        await submitTerminalInput(deps.runtime, session.id, renderStopFailureRecoveryPrompt());
         await deps.sessionService.markRoleActivityRunning(context.project.repoRoot, context.taskSlug, input.role);
-        return true;
+    }
+    async function markStopFailureRecoveryFailed(input, context, failure, attempt, timestamp = now()) {
+        clearStopFailureRetryTimer(context.project.repoRoot, context.taskSlug, input.role);
+        await deps.roundService.setRoleRecovery({
+            ...createRoundStateInput(context),
+            recovery: {
+                role: input.role,
+                status: "failed",
+                attempt,
+                maxAttempts: MAX_ROLE_RETRY_ATTEMPTS,
+                lastFailureAt: timestamp,
+                error: failure.error,
+                errorDetails: failure.errorDetails,
+                lastAssistantMessage: failure.lastAssistantMessage,
+                retryable: failure.retryable,
+                failedAt: timestamp
+            }
+        });
     }
     function clearStopFailureRecovery(repoRoot, taskSlug, role) {
-        stopFailureRecoveryAttempts.delete(stopFailureRecoveryKey(repoRoot, taskSlug, role));
+        clearStopFailureRetryTimer(repoRoot, taskSlug, role);
+    }
+    async function clearStopFailureRecoveryState(context, role) {
+        clearStopFailureRecovery(context.project.repoRoot, context.taskSlug, role);
+        await deps.roundService.clearRoleRecovery?.({
+            ...createRoundStateInput(context),
+            role
+        });
+    }
+    function clearStopFailureRetryTimer(repoRoot, taskSlug, role) {
+        const key = stopFailureRecoveryKey(repoRoot, taskSlug, role);
+        const timer = stopFailureRetryTimers.get(key);
+        if (timer === undefined) {
+            return;
+        }
+        retryClearTimeout(timer);
+        stopFailureRetryTimers.delete(key);
     }
     function stopFailureRecoveryKey(repoRoot, taskSlug, role) {
         return `${repoRoot}:${taskSlug}:${role}`;
     }
-    function renderStopFailureRecoveryPrompt(attempt) {
+    function createRoundStateInput(context) {
+        return {
+            repoRoot: context.project.repoRoot,
+            stateRepoRoot: context.taskRepoRoot,
+            stateRoot: context.config.stateRoot,
+            taskSlug: context.taskSlug
+        };
+    }
+    function renderStopFailureRecoveryPrompt() {
         return [
             "[VCM Recovery]",
-            "Your previous turn ended unexpectedly after context compaction or an API error.",
-            "Continue the same assigned work from the current repository and VCM handoff state.",
-            "Do not repeat completed edits, duplicate validation, or duplicate route messages.",
-            "If the assigned work is already complete, write/send the expected VCM handoff now.",
-            `Recovery attempt: ${attempt}/${MAX_STOP_FAILURE_RECOVERY_ATTEMPTS}.`
+            "Previous turn ended unexpectedly. Continue from current repo + VCM handoff state.",
+            "",
+            "Check whether your assigned work is already complete.",
+            "If complete, write the expected VCM completion artifact now.",
+            "Do not repeat completed edits, validation, or route messages."
         ].join("\n");
     }
     async function handlePermissionRequestHook(input) {
@@ -470,6 +590,38 @@ function throwUnsupportedEvent(eventName) {
         hint: "Use the matching VCM hook endpoint for this event."
     });
 }
+function parseStopFailureDiagnostic(event) {
+    const error = (normalizeDiagnosticString(event.error, 200) ?? "unknown").toLowerCase();
+    const errorDetails = normalizeDiagnosticString(event.error_details, DIAGNOSTIC_SNIPPET_MAX_LENGTH);
+    const lastAssistantMessage = normalizeDiagnosticString(event.last_assistant_message, DIAGNOSTIC_SNIPPET_MAX_LENGTH);
+    return {
+        error,
+        errorDetails,
+        lastAssistantMessage,
+        retryable: !NON_RETRYABLE_STOP_FAILURE_ERRORS.has(error)
+    };
+}
+function normalizeDiagnosticString(value, maxLength) {
+    let text;
+    if (typeof value === "string") {
+        text = value;
+    }
+    else if (value !== undefined && value !== null) {
+        try {
+            text = JSON.stringify(value);
+        }
+        catch {
+            text = String(value);
+        }
+    }
+    const trimmed = text?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    return trimmed.length > maxLength
+        ? `${trimmed.slice(0, maxLength)}...`
+        : trimmed;
+}
 function stringOrUndefined(value) {
     return typeof value === "string" ? value : undefined;
 }

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

@@ -1,4 +1,6 @@
+import { createHash } from "node:crypto";
 import path from "node:path";
+import { checkMarkdownArtifact } from "../../shared/validation/artifact-check.js";
 import { resolveRepoPath, toRepoRelativePath } from "../adapters/filesystem.js";
 import { VcmError } from "../errors.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
@@ -6,6 +8,7 @@ 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`;
 export function createHarnessFeedbackService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
@@ -13,6 +16,80 @@ export function createHarnessFeedbackService(deps) {
         await maybeDispatchNext(repoRoot, activeTaskSlug);
         return buildStateReport(repoRoot);
     }
+    async function startTaskRetrospective(repoRoot, input) {
+        const taskSlug = input.taskSlug.trim();
+        if (!taskSlug) {
+            throw new VcmError({
+                code: "HARNESS_TASK_REQUIRED",
+                message: "Select an active task before reviewing task harness.",
+                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."
+            });
+        }
+        const finalAcceptancePath = path.posix.join(input.handoffDir, "final-acceptance.md");
+        const finalAcceptanceAbsolutePath = resolveRepoPath(input.taskRepoRoot, finalAcceptancePath);
+        const finalAcceptanceContent = await readAbsoluteOptionalText(finalAcceptanceAbsolutePath);
+        const finalAcceptanceCheck = checkMarkdownArtifact("final-acceptance", finalAcceptancePath, finalAcceptanceContent ?? null);
+        if (finalAcceptanceCheck.status !== "ok" || !finalAcceptanceContent) {
+            throw new VcmError({
+                code: "TASK_FINAL_ACCEPTANCE_NOT_READY",
+                message: "Task final acceptance is not complete yet.",
+                statusCode: 409,
+                hint: `${finalAcceptancePath} must pass the final-acceptance artifact check before Task Harness Retrospective can start.`
+            });
+        }
+        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",
+            taskSlug,
+            summary: "Review the completed task workflow for reusable harness problems.",
+            trigger: input.trigger,
+            finalAcceptanceHash,
+            feedbackPath,
+            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 || state.status !== "awaiting_user_approval") {
@@ -48,6 +125,7 @@ export function createHarnessFeedbackService(deps) {
                 }
             };
             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);
         }
@@ -63,6 +141,7 @@ export function createHarnessFeedbackService(deps) {
             }
         };
         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);
     }
@@ -76,14 +155,16 @@ export function createHarnessFeedbackService(deps) {
         }
         const timestamp = now();
         if (state.status === "analyzing") {
-            await persistStoredState(repoRoot, {
+            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") {
@@ -132,6 +213,7 @@ export function createHarnessFeedbackService(deps) {
         const active = {
             ...next,
             feedbackPath: next.path,
+            source: next.source ?? "role-feedback",
             analysisPath,
             applyReportPath,
             startedAt: timestamp,
@@ -209,12 +291,15 @@ export function createHarnessFeedbackService(deps) {
             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,
@@ -249,6 +334,7 @@ export function createHarnessFeedbackService(deps) {
             id,
             title: compactLine(title),
             path: relativePath,
+            source: "role-feedback",
             reporterRole: metadata["reporter role"] ?? metadata.reporter,
             taskSlug: metadata["task slug"] ?? metadata.task,
             summary: metadata.summary
@@ -278,6 +364,16 @@ export function createHarnessFeedbackService(deps) {
             "</HARNESS_FEEDBACK>"
         ].join("\n");
     }
+    function buildTaskRetrospectivePrompt(repoRoot, active) {
+        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)}`,
+            "End your turn after writing the result."
+        ].join("\n");
+    }
     function buildFeedbackCommentPrompt(repoRoot, active, comment) {
         return [
             "[VCM Harness Feedback Revision]",
@@ -345,6 +441,7 @@ export function createHarnessFeedbackService(deps) {
             comment,
             completedAt: now()
         });
+        await persistTaskRetrospectiveMarker(repoRoot, state.active, outcome === "rejected" ? "rejected" : "completed");
         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 });
     }
@@ -357,6 +454,7 @@ export function createHarnessFeedbackService(deps) {
         if (state?.version !== 1 || !state.active?.id || !state.status) {
             return undefined;
         }
+        state.active.source = state.active.source ?? "role-feedback";
         return state;
     }
     async function persistStoredState(repoRoot, state) {
@@ -372,8 +470,38 @@ export function createHarnessFeedbackService(deps) {
         }
         return deps.fs.readText(absolutePath);
     }
+    async function readAbsoluteOptionalText(absolutePath) {
+        if (!(await deps.fs.pathExists(absolutePath))) {
+            return undefined;
+        }
+        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
@@ -397,10 +525,29 @@ 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`;
+}
 function sanitizeFeedbackId(value) {
     const sanitized = value.replace(/[^A-Za-z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
     return sanitized || "feedback";
 }
+function sha256(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
 export function getHarnessFeedbackRelativePath(repoRoot, absolutePath) {
     return toRepoRelativePath(repoRoot, absolutePath);
 }