vibe-coding-master 0.6.22 → 0.6.23

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/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";
@@ -94,6 +95,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,6 +106,7 @@ export async function createServer(deps, options = {}) {
         translationWorkerService: deps.translationWorkerService,
         harnessService: deps.harnessService,
         harnessFeedbackService: deps.harnessFeedbackService,
+        autoMemoryService: deps.autoMemoryService,
         runtimeCoordinator: deps.runtimeCoordinator
     });
     registerTaskRoutes(app, {
@@ -222,6 +225,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,
@@ -314,6 +327,7 @@ export function createDefaultServerDeps(options = {}) {
         translationService,
         harnessService,
         harnessFeedbackService,
+        autoMemoryService,
         roundService,
         gatewayService,
         async getStateRoot(repoRoot) {
@@ -338,6 +352,7 @@ export function createDefaultServerDeps(options = {}) {
         runtime,
         harnessService,
         harnessFeedbackService,
+        autoMemoryService,
         gatewayService,
         jobGuard: createJobGuardService(),
         translationWorkerService
@@ -363,6 +378,7 @@ export function createDefaultServerDeps(options = {}) {
         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),