vibe-coding-master 0.6.22 → 0.7.0

package/README.md

@@ -333,7 +333,7 @@ Gateway can:
 - create a task
 - close a task with confirmation
 - send plain text to Project Manager
-- push PM replies back to the active chat
+- push the PM Round-final reply and Round status back to the active chat
 - translate mobile messages when Gateway translation is enabled
 
 Gateway does not expose the embedded terminal and does not send directly to
@@ -361,6 +361,12 @@ Common commands:
 Gateway credentials and audit logs are stored in app-local state, not connected
 repositories.
 
+When Gateway starts, VCM enables conversation translation, auto-send, and the
+`Round final reply` scope. On a normal Round end, Gateway sends the PM original
+reply first, then reuses the matching translation already produced for the
+translation panel. `/retry` explicitly creates a new translation only when the
+previous Gateway translation failed or was unavailable.
+
 ## Harness Studio
 
 Harness Studio is the UI for VCM harness maintenance.
@@ -371,8 +377,10 @@ Use it to:
 - run bootstrap
 - open Harness Engineer
 - review harness files
+- view and edit shared or role-specific VCM memory
+- review and revert memory changes recorded in the active task worktree
 - copy file paths for discussion
-- review task harness after a task completes
+- review task harness after post-task memory processing completes
 - inspect commit diffs for harness changes
 - merge task harness commits back to the connected repository branch when
   appropriate
@@ -380,6 +388,32 @@ Use it to:
 Harness Engineer is project-scoped and resumable. When it performs task work,
 VCM runs it from the active task worktree.
 
+### Auto Memory
+
+Enable `Auto memory` in the `VCM Harness` sidebar group to collect durable role
+knowledge after a complete task passes Final Acceptance. Project Manager,
+Architect, Coder, Tester, and an enabled Gate Reviewer submit memory drafts in
+sequence. Harness Engineer verifies and consolidates them before VCM applies
+the result.
+
+Canonical memory is stored under the base repository's `.ai/vcm/memory/`.
+Harness Studio shows current memory and task-local applied history. Memory is
+applied before user review; while the task worktree remains available, the user
+can edit current memory or revert a recorded change.
+
+Post-task processing is ordered by the backend:
+
+```text
+Final Acceptance
+  -> Auto Memory, when enabled
+  -> Task Harness Retrospective
+```
+
+Auto Memory adds no retrospective prerequisite when it is disabled. When it is
+enabled, both automatic and manual retrospective requests wait until memory has
+been applied for the current Final Acceptance. A failed memory review must be
+retried from Harness Studio before retrospective can run.
+
 ## Closing a Task
 
 `Close Task` is destructive.
@@ -480,5 +514,5 @@ npm start
 - `docs/ARCHITECTURE.md`: repository architecture
 - `docs/TESTING.md`: validation strategy
 - `docs/vcm-cc-best-practices.md`: current VCM Claude Code harness practice
-- `docs/v0.5-custom-workflow-plan.md`: future custom workflow plan
+- `docs/v0.5-custom-workflow-plan.md`: deferred custom workflow proposal
 - `docs/cc-best-practices.md`: archived generic Claude Code harness notes

package/dist/backend/adapters/filesystem.js

@@ -47,6 +47,14 @@ export function createNodeFileSystemAdapter() {
                 await fs.writeFile(targetPath, content, "utf8");
             });
         },
+        async writeTextAtomic(targetPath, content) {
+            await runFileOperation(async () => {
+                await fs.mkdir(path.dirname(targetPath), { recursive: true });
+                const tempPath = `${targetPath}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
+                await fs.writeFile(tempPath, content, "utf8");
+                await fs.rename(tempPath, targetPath);
+            });
+        },
         async appendText(targetPath, content) {
             await runFileOperation(async () => {
                 await fs.mkdir(path.dirname(targetPath), { recursive: true });

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

@@ -66,11 +66,13 @@ export function registerHarnessRoutes(app, deps) {
     });
     app.post("/api/projects/harness/bootstrap/start", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
         await deps.harnessFeedbackService.assertHarnessEngineerAvailable(project.repoRoot);
         return deps.harnessService.startHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
     });
     app.post("/api/projects/harness/bootstrap/restart", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
         await deps.harnessFeedbackService.assertHarnessEngineerAvailable(project.repoRoot);
         return deps.harnessService.restartHarnessBootstrap(project.repoRoot, task.worktreePath, request.body ?? {});
     });
@@ -80,6 +82,7 @@ export function registerHarnessRoutes(app, deps) {
     });
     app.post("/api/projects/harness/bootstrap/run", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
         await deps.harnessFeedbackService.assertHarnessEngineerAvailable(project.repoRoot);
         return deps.harnessService.runHarnessBootstrap(project.repoRoot, task.worktreePath);
     });
@@ -93,14 +96,26 @@ export function registerHarnessRoutes(app, deps) {
     });
     app.post("/api/projects/harness/engineer/session/start", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
+        if (request.body?.taskSlug) {
+            const task = await deps.taskService.loadTask(project.repoRoot, request.body.taskSlug);
+            await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
+        }
         return deps.sessionService.startProjectHarnessEngineerSession(project.repoRoot, request.body);
     });
     app.post("/api/projects/harness/engineer/session/resume", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
+        if (request.body?.taskSlug) {
+            const task = await deps.taskService.loadTask(project.repoRoot, request.body.taskSlug);
+            await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
+        }
         return deps.sessionService.resumeProjectHarnessEngineerSession(project.repoRoot, request.body);
     });
     app.post("/api/projects/harness/engineer/session/restart", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
+        if (request.body?.taskSlug) {
+            const task = await deps.taskService.loadTask(project.repoRoot, request.body.taskSlug);
+            await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
+        }
         return deps.sessionService.restartProjectHarnessEngineerSession(project.repoRoot, request.body);
     });
     app.post("/api/projects/harness/engineer/session/stop", async () => {
@@ -127,6 +142,10 @@ export function registerHarnessRoutes(app, deps) {
             });
         }
         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,
@@ -135,6 +154,14 @@ export function registerHarnessRoutes(app, deps) {
     });
     app.post("/api/projects/harness/task-retrospective", async (request) => {
         const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        await deps.autoMemoryService.assertTaskRetrospectiveReady({
+            baseRepoRoot: project.repoRoot,
+            taskRepoRoot: task.worktreePath,
+            taskSlug: task.taskSlug,
+            handoffDir: task.handoffDir,
+            roundReady: true
+        });
+        await deps.autoMemoryService.assertHarnessEngineerAvailable(task.worktreePath);
         const trigger = request.body?.trigger === "auto" ? "auto" : "manual";
         return deps.harnessFeedbackService.startTaskRetrospective(project.repoRoot, {
             taskSlug: task.taskSlug,
@@ -143,6 +170,33 @@ export function registerHarnessRoutes(app, deps) {
             trigger
         });
     });
+    app.get("/api/projects/harness/memory", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
+        return deps.autoMemoryService.getState(project.repoRoot, task.worktreePath);
+    });
+    app.get("/api/projects/harness/memory/file", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.query.taskSlug);
+        return deps.autoMemoryService.getFile(project.repoRoot, task.worktreePath, request.query.path ?? "");
+    });
+    app.put("/api/projects/harness/memory/file", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.query.taskSlug ?? request.body?.taskSlug);
+        if (typeof request.body?.content !== "string") {
+            throw new VcmError({
+                code: "MEMORY_FILE_CONTENT_INVALID",
+                message: "Memory file content must be a string.",
+                statusCode: 400
+            });
+        }
+        return deps.autoMemoryService.updateFile(project.repoRoot, task.worktreePath, task.taskSlug, request.query.path ?? "", request.body.content);
+    });
+    app.post("/api/projects/harness/memory/revert", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.autoMemoryService.revertRun(project.repoRoot, task.worktreePath, request.body?.runId ?? "");
+    });
+    app.post("/api/projects/harness/memory/retry", async (request) => {
+        const { project, task } = await requireHarnessTaskContext(deps, request.body?.taskSlug);
+        return deps.autoMemoryService.retryFailedReview(project.repoRoot, task.worktreePath);
+    });
 }
 function degradedHarnessStatus(error) {
     return {

package/dist/backend/api/runtime-state-routes.js

@@ -18,14 +18,16 @@ export function registerRuntimeStateRoutes(app, deps) {
                 harnessStatus: null,
                 harnessBootstrapStatus: null,
                 harnessFeedbackState,
+                autoMemoryState: null,
                 gatewayStatus: coordinated.gatewayStatus
             };
         }
         try {
             const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
-            const [harnessStatus, harnessBootstrapStatus] = await Promise.all([
+            const [harnessStatus, harnessBootstrapStatus, autoMemoryState] = await Promise.all([
                 withOpenFileLimitFallback(() => deps.harnessService.getHarnessStatus(task.worktreePath), (error) => degradedHarnessStatus(error)),
-                withOpenFileLimitFallback(() => deps.harnessService.getBootstrapStatus(project.repoRoot, task.worktreePath), (error) => degradedBootstrapStatus(error))
+                withOpenFileLimitFallback(() => deps.harnessService.getBootstrapStatus(project.repoRoot, task.worktreePath), (error) => degradedBootstrapStatus(error)),
+                deps.autoMemoryService.getState(project.repoRoot, task.worktreePath)
             ]);
             return {
                 translatorSession,
@@ -34,6 +36,7 @@ export function registerRuntimeStateRoutes(app, deps) {
                 harnessStatus,
                 harnessBootstrapStatus,
                 harnessFeedbackState,
+                autoMemoryState,
                 gatewayStatus: coordinated.gatewayStatus
             };
         }
@@ -46,6 +49,7 @@ export function registerRuntimeStateRoutes(app, deps) {
                     harnessStatus: degradedHarnessStatus(error),
                     harnessBootstrapStatus: degradedBootstrapStatus(error),
                     harnessFeedbackState,
+                    autoMemoryState: null,
                     gatewayStatus: coordinated.gatewayStatus
                 };
             }

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

@@ -1,4 +1,4 @@
-import { DISPATCHABLE_ROLES, VCM_ROLE_NAMES } from "../../shared/constants.js";
+import { DISPATCHABLE_ROLES } from "../../shared/constants.js";
 import { isOpenFileLimitError, VcmError } from "../errors.js";
 import { getTaskRuntimeRepoRoot } from "../services/task-service.js";
 export function registerTaskRoutes(app, deps) {
@@ -92,39 +92,9 @@ export function registerTaskRoutes(app, deps) {
     });
     app.post("/api/tasks/:taskSlug/cleanup", async (request) => {
         const project = await requireCurrentProject(deps.projectService);
-        const task = await deps.taskService.loadTask(project.repoRoot, request.params.taskSlug);
-        await stopRunningRoleSessions(deps, project.repoRoot, request.params.taskSlug);
-        await moveProjectToolSessionsToSafeCwd(deps, project.repoRoot);
-        await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), request.params.taskSlug, { clearCache: true });
-        deps.roundService.stopTask(request.params.taskSlug);
-        return deps.taskService.cleanupTask(project.repoRoot, request.params.taskSlug, request.body ?? {});
+        return deps.taskCloseService.closeTask(project.repoRoot, request.params.taskSlug);
     });
 }
-async function stopRunningRoleSessions(deps, repoRoot, taskSlug) {
-    const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
-    for (const session of sessions) {
-        if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
-            await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
-        }
-    }
-}
-async function moveProjectToolSessionsToSafeCwd(deps, repoRoot) {
-    await Promise.all([
-        ignoreMissingSession(deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot)),
-        ignoreMissingSession(deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot))
-    ]);
-}
-async function ignoreMissingSession(operation) {
-    try {
-        await operation;
-    }
-    catch (error) {
-        if (error instanceof VcmError && error.code === "SESSION_MISSING") {
-            return;
-        }
-        throw error;
-    }
-}
 async function requireCurrentProject(projectService) {
     const project = await projectService.getCurrentProject();
     if (!project) {

package/dist/backend/cli/install-vcm-harness.js

@@ -36,7 +36,7 @@ const LEGACY_CODEX_HARNESS_PATHS = [
     ".ai/tools/request-codex-review"
 ];
 const VCM_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code" -H "content-type: application/json" --data-binary @- >/dev/null || true'`;
-const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
+const VCM_STOP_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --retry 2 --retry-delay 1 --retry-all-errors --connect-timeout 1 --max-time 2 -X POST "\${VCM_API_URL}/api/hooks/claude-code/stop" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_PERMISSION_REQUEST_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ] || [ -z "\${VCM_API_URL:-}" ]; then exit 0; fi; node -e '"'"'let s="";process.stdin.setEncoding("utf8");process.stdin.on("data",d=>s+=d);process.stdin.on("end",()=>{let event={};try{event=s.trim()?JSON.parse(s):{};}catch{event={raw:s};}process.stdout.write(JSON.stringify({taskSlug:process.env.VCM_TASK_SLUG,role:process.env.VCM_ROLE,event}));});'"'"' | curl -fsS --max-time 5 -X POST "\${VCM_API_URL}/api/hooks/claude-code/permission-request" -H "content-type: application/json" --data-binary @- || true'`;
 const VCM_BASH_GUARD_HOOK_COMMAND = `sh -c 'if [ -z "\${VCM_TASK_SLUG:-}" ] || [ -z "\${VCM_ROLE:-}" ]; then exit 0; fi; guard=""; repo="$(git rev-parse --show-toplevel 2>/dev/null || true)"; if [ -n "$repo" ] && [ -f "$repo/.ai/tools/vcm-bash-guard" ]; then guard="$repo/.ai/tools/vcm-bash-guard"; else cwd="$(pwd -P 2>/dev/null || pwd)"; dir="$cwd"; while [ -n "$dir" ] && [ "$dir" != "/" ]; do if [ -f "$dir/.ai/tools/vcm-bash-guard" ]; then guard="$dir/.ai/tools/vcm-bash-guard"; break; fi; dir="$(dirname "$dir")"; done; if [ -z "$guard" ] && [ -n "\${CLAUDE_PROJECT_DIR:-}" ] && [ -f "\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard" ]; then guard="\${CLAUDE_PROJECT_DIR}/.ai/tools/vcm-bash-guard"; fi; fi; [ -n "$guard" ] || exit 0; python3 "$guard" || exit 0'`;
 const VCM_BASH_DEFAULT_TIMEOUT_MS = "600000";

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

@@ -1,4 +1,3 @@
-import { 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";
@@ -605,15 +604,7 @@ export function createGatewayService(deps) {
                 hint: settings.currentTaskSlug ? `Use /close-task confirm ${settings.currentTaskSlug}` : undefined
             });
         }
-        const task = await deps.taskService.loadTask(project.repoRoot, taskSlug);
-        await stopRunningRoleSessions(project.repoRoot, taskSlug);
-        await moveProjectToolSessionsToSafeCwd(project.repoRoot);
-        await deps.translationService.stopTask(getTaskRuntimeRepoRoot(task), taskSlug, { clearCache: true });
-        deps.roundService.stopTask(taskSlug);
-        const result = await deps.taskService.cleanupTask(project.repoRoot, taskSlug, {
-            force: true,
-            forceDeleteBranch: true
-        });
+        const result = await deps.taskCloseService.closeTask(project.repoRoot, taskSlug);
         clearFailedTranslation(project.repoRoot, taskSlug);
         const latestPmReplies = { ...settings.latestPmReplies };
         delete latestPmReplies[latestPmReplyKey(project.repoRoot, taskSlug)];
@@ -629,8 +620,9 @@ export function createGatewayService(deps) {
         });
         const lines = [
             `Closed task: ${result.taskSlug}`,
-            result.removedWorktreePath ? `removed worktree: ${result.removedWorktreePath}` : "removed worktree: none",
-            result.deletedBranch ? `deleted branch: ${result.deletedBranch}` : "deleted branch: none",
+            `worktree removed: ${result.worktreeRemoved ? "yes" : "no"}`,
+            `branch deleted: ${result.branchDeleted ? "yes" : "no"}`,
+            `task state removed: ${result.stateRemoved ? "yes" : "no"}`,
             `removed state paths: ${result.removedStatePaths.length}`
         ];
         if (result.warnings?.length) {
@@ -638,31 +630,6 @@ export function createGatewayService(deps) {
         }
         return lines.join("\n");
     }
-    async function stopRunningRoleSessions(repoRoot, taskSlug) {
-        const sessions = await deps.sessionService.listRoleSessions(repoRoot, taskSlug);
-        for (const session of sessions) {
-            if (session.status === "running" && VCM_ROLE_NAMES.some((role) => role === session.role)) {
-                await deps.sessionService.stopRoleSession(repoRoot, taskSlug, session.role);
-            }
-        }
-    }
-    async function moveProjectToolSessionsToSafeCwd(repoRoot) {
-        await Promise.all([
-            ignoreMissingSession(deps.sessionService.moveProjectTranslatorSessionToSafeCwd(repoRoot)),
-            ignoreMissingSession(deps.sessionService.moveProjectHarnessEngineerSessionToSafeCwd(repoRoot))
-        ]);
-    }
-    async function ignoreMissingSession(operation) {
-        try {
-            await operation;
-        }
-        catch (error) {
-            if (error instanceof VcmError && error.code === "SESSION_MISSING") {
-                return;
-            }
-            throw error;
-        }
-    }
     async function setGatewayTranslation(enabled) {
         const settings = await deps.settings.updateSettings({ translationEnabled: enabled });
         return `Gateway translation ${settings.translationEnabled ? "on" : "off"}.`;

package/dist/backend/server.js

@@ -9,6 +9,7 @@ import { createCommandDispatcher } from "./services/command-dispatcher.js";
 import { createClaudeHookService } from "./services/claude-hook-service.js";
 import { createGitAdapter } from "./adapters/git-adapter.js";
 import { createAppSettingsService } from "./services/app-settings-service.js";
+import { createAutoMemoryService } from "./services/auto-memory-service.js";
 import { createClaudeTranscriptService } from "./services/claude-transcript-service.js";
 import { createGateReviewService } from "./services/gate-review-service.js";
 import { createHarnessFeedbackService } from "./services/harness-feedback-service.js";
@@ -34,9 +35,11 @@ import { createRuntimeCoordinatorService } from "./services/runtime-coordinator-
 import { createRuntimeRecoveryService } from "./services/runtime-recovery-service.js";
 import { createStatusService } from "./services/status-service.js";
 import { createTaskService } from "./services/task-service.js";
+import { createTaskCloseService } from "./services/task-close-service.js";
 import { createTaskLaunchService } from "./services/task-launch-service.js";
 import { createTerminalInterruptService } from "./services/terminal-interrupt-service.js";
 import { createTranslationService } from "./services/translation-service.js";
+import { createTurnReconcilerService } from "./services/turn-reconciler-service.js";
 import { createDiagnosticsService } from "./services/diagnostics-service.js";
 import { registerAppSettingsRoutes } from "./api/app-settings-routes.js";
 import { registerArtifactRoutes } from "./api/artifact-routes.js";
@@ -94,6 +97,7 @@ export async function createServer(deps, options = {}) {
         projectService: deps.projectService,
         harnessService: deps.harnessService,
         harnessFeedbackService: deps.harnessFeedbackService,
+        autoMemoryService: deps.autoMemoryService,
         sessionService: deps.sessionService,
         taskService: deps.taskService
     });
@@ -104,16 +108,16 @@ export async function createServer(deps, options = {}) {
         translationWorkerService: deps.translationWorkerService,
         harnessService: deps.harnessService,
         harnessFeedbackService: deps.harnessFeedbackService,
+        autoMemoryService: deps.autoMemoryService,
         runtimeCoordinator: deps.runtimeCoordinator
     });
     registerTaskRoutes(app, {
         projectService: deps.projectService,
         taskService: deps.taskService,
-        sessionService: deps.sessionService,
+        taskCloseService: deps.taskCloseService,
         statusService: deps.statusService,
         messageService: deps.messageService,
         taskLaunchService: deps.taskLaunchService,
-        translationService: deps.translationService,
         roundService: deps.roundService
     });
     registerSessionRoutes(app, {
@@ -151,9 +155,11 @@ export async function createServer(deps, options = {}) {
     });
     app.addHook("onReady", async () => {
         await cleanupRecentTranslationRuntime(deps);
+        deps.runtimeCoordinator.start();
         await deps.gatewayService.start();
     });
     app.addHook("onClose", async () => {
+        deps.runtimeCoordinator.stop();
         await deps.gatewayService.stop();
     });
     if (options.staticDir) {
@@ -222,6 +228,16 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         sessionService
     });
+    const autoMemoryService = createAutoMemoryService({
+        fs,
+        runtime,
+        sessionService,
+        appSettings,
+        async isHarnessEngineerAvailable(repoRoot) {
+            const state = await harnessFeedbackService.getState(repoRoot);
+            return state.status === "idle";
+        }
+    });
     const commandDispatcher = createCommandDispatcher({
         runtime,
         sessionService,
@@ -293,6 +309,12 @@ export function createDefaultServerDeps(options = {}) {
         fs,
         auditPath: gatewaySettings.getAuditPath()
     });
+    const taskCloseService = createTaskCloseService({
+        taskService,
+        sessionService,
+        translationService,
+        roundService
+    });
     const gatewayService = createGatewayService({
         fs,
         settings: gatewaySettings,
@@ -300,6 +322,7 @@ export function createDefaultServerDeps(options = {}) {
         channels: gatewayChannels,
         projectService,
         taskService,
+        taskCloseService,
         sessionService,
         taskLaunchService,
         translationService,
@@ -307,19 +330,6 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         appSettings
     });
-    const runtimeCoordinator = createRuntimeCoordinatorService({
-        appSettings,
-        taskService,
-        sessionService,
-        translationService,
-        harnessService,
-        harnessFeedbackService,
-        roundService,
-        gatewayService,
-        async getStateRoot(repoRoot) {
-            return (await projectService.loadConfig(repoRoot)).stateRoot;
-        }
-    });
     const runtimeRecoveryService = createRuntimeRecoveryService({
         fs,
         runtime,
@@ -338,10 +348,33 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         harnessService,
         harnessFeedbackService,
+        autoMemoryService,
         gatewayService,
         jobGuard: createJobGuardService(),
         translationWorkerService
     });
+    const turnReconciler = createTurnReconcilerService({
+        sessionService,
+        roundService,
+        claudeHookService,
+        runtime
+    });
+    const runtimeCoordinator = createRuntimeCoordinatorService({
+        appSettings,
+        projectService,
+        taskService,
+        sessionService,
+        translationService,
+        harnessService,
+        harnessFeedbackService,
+        autoMemoryService,
+        roundService,
+        gatewayService,
+        turnReconciler,
+        async getStateRoot(repoRoot) {
+            return (await projectService.loadConfig(repoRoot)).stateRoot;
+        }
+    });
     const terminalInterruptService = createTerminalInterruptService({
         runtime,
         projectService,
@@ -359,10 +392,12 @@ export function createDefaultServerDeps(options = {}) {
         appSettings,
         projectService,
         taskService,
+        taskCloseService,
         sessionService,
         artifactService,
         harnessService,
         harnessFeedbackService,
+        autoMemoryService,
         commandDispatcher,
         claudeHookService,
         messageService,

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

@@ -242,6 +242,7 @@ function normalizePreferences(input) {
         roleRetryEnabled: candidate.roleRetryEnabled !== false,
         permissionRequestMode: normalizePermissionRequestMode(candidate.permissionRequestMode),
         autoTaskHarnessReviewEnabled: candidate.autoTaskHarnessReviewEnabled === true,
+        autoMemoryEnabled: candidate.autoMemoryEnabled === true,
         translationEnabled: candidate.translationEnabled === true,
         translationAutoSendEnabled: candidate.translationAutoSendEnabled === true,
         translationTargetLanguage: normalizeTranslationTargetLanguage(candidate.translationTargetLanguage),