vibe-coding-master 0.6.22 → 0.6.23

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

@@ -97,6 +97,28 @@ export function createClaudeHookService(deps) {
             transcriptPath: stringOrUndefined(input.event.transcript_path),
             cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
         });
+        const activeTask = deps.autoMemoryService
+            ? (await deps.taskService.listTasks(context.project.repoRoot))
+                .find((task) => task.cleanupStatus !== "cleaned")
+            : undefined;
+        const memoryHandled = activeTask
+            ? await deps.autoMemoryService?.handleHarnessEngineerHook({
+                baseRepoRoot: context.project.repoRoot,
+                taskRepoRoot: getTaskRuntimeRepoRoot(activeTask),
+                taskSlug: activeTask.taskSlug,
+                eventName
+            })
+            : false;
+        if (memoryHandled) {
+            return {
+                ok: true,
+                eventName,
+                taskSlug: activeTask?.taskSlug ?? input.taskSlug,
+                role: input.role,
+                sessionUpdated: Boolean(session),
+                dispatchedCount: 0
+            };
+        }
         await deps.harnessService?.recordHarnessBootstrapHook(context.project.repoRoot, {
             eventName,
             sessionId: session?.id,
@@ -131,6 +153,10 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
+        if (memoryResult) {
+            return memoryResult;
+        }
         const boundToTask = await isHookSessionBoundToTask(context, input.role);
         if (boundToTask) {
             deps.jobGuard?.notePromptSubmitted({
@@ -194,6 +220,10 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
+        if (memoryResult) {
+            return memoryResult;
+        }
         await clearStopFailureRecoveryState(context, input.role);
         if (options.allowBlock && deps.jobGuard) {
             const verdict = await deps.jobGuard.evaluateStop({
@@ -228,6 +258,10 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
+        if (memoryResult) {
+            return memoryResult;
+        }
         const routeDispatchInput = createRouteDispatchInput(input, context);
         const pending = await deps.messageService.listPendingRouteFiles(routeDispatchInput);
         const hasCompletionEvidence = pending.some((routeFile) => routeFile.fromRole === input.role);
@@ -284,6 +318,10 @@ export function createClaudeHookService(deps) {
             throwUnsupportedEvent(eventName);
         }
         const context = await getHookContext(input);
+        const memoryResult = await processAutoMemoryRoleHook(input, context, eventName);
+        if (memoryResult) {
+            return memoryResult;
+        }
         const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
             taskSlug: context.taskSlug,
             role: input.role,
@@ -380,6 +418,34 @@ export function createClaudeHookService(deps) {
             dispatchedCount: dispatched.filter((result) => result.delivered).length
         };
     }
+    async function processAutoMemoryRoleHook(input, context, eventName) {
+        if (!deps.autoMemoryService || !(await deps.autoMemoryService.isRoleMemoryTurn(context.taskRepoRoot, input.role))) {
+            return undefined;
+        }
+        const session = await deps.sessionService.recordClaudeHookEvent(context.project.repoRoot, {
+            taskSlug: context.taskSlug,
+            role: input.role,
+            eventName,
+            claudeSessionId: stringOrUndefined(input.event.session_id),
+            transcriptPath: stringOrUndefined(input.event.transcript_path),
+            cwd: stringOrUndefined(input.event.cwd) ?? stringOrUndefined(input.event.new_cwd)
+        });
+        await deps.autoMemoryService.handleRoleHook({
+            baseRepoRoot: context.project.repoRoot,
+            taskRepoRoot: context.taskRepoRoot,
+            taskSlug: context.taskSlug,
+            role: input.role,
+            eventName
+        });
+        return {
+            ok: true,
+            eventName,
+            taskSlug: context.taskSlug,
+            role: input.role,
+            sessionUpdated: Boolean(session),
+            dispatchedCount: 0
+        };
+    }
     function createRouteDispatchInput(input, context, stoppedRole) {
         return {
             repoRoot: context.project.repoRoot,

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

@@ -55,8 +55,12 @@ export function createRuntimeCoordinatorService(deps) {
                 else {
                     await deps.translationService.stopTask(taskRepoRoot, activeTask.taskSlug).catch(() => undefined);
                 }
+                await reconcileAutoMemory(repoRoot, activeTask);
                 if (preferences.autoTaskHarnessReviewEnabled) {
-                    await maybeStartTaskHarnessRetrospective(repoRoot, activeTask);
+                    const memoryReadiness = await getTaskRetrospectiveMemoryReadiness(repoRoot, activeTask);
+                    if (memoryReadiness.ready) {
+                        await maybeStartTaskHarnessRetrospective(repoRoot, activeTask);
+                    }
                 }
                 return { activeTask, gatewayStatus };
             });
@@ -159,4 +163,33 @@ export function createRuntimeCoordinatorService(deps) {
             throw error;
         }
     }
+    async function reconcileAutoMemory(repoRoot, task) {
+        const stateRoot = await deps.getStateRoot(repoRoot);
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        const roundState = await deps.roundService.getSessionRoundState({
+            repoRoot,
+            stateRepoRoot: taskRepoRoot,
+            stateRoot,
+            taskSlug: task.taskSlug
+        });
+        return deps.autoMemoryService.reconcileTask({
+            baseRepoRoot: repoRoot,
+            taskRepoRoot,
+            taskSlug: task.taskSlug,
+            handoffDir: task.handoffDir,
+            roundReady: roundState.status === "stopped"
+                && Boolean(roundState.roundId)
+                && roundState.roleRecovery?.status !== "failed"
+        });
+    }
+    async function getTaskRetrospectiveMemoryReadiness(repoRoot, task) {
+        const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        return deps.autoMemoryService.getTaskRetrospectiveReadiness({
+            baseRepoRoot: repoRoot,
+            taskRepoRoot,
+            taskSlug: task.taskSlug,
+            handoffDir: task.handoffDir,
+            roundReady: true
+        });
+    }
 }

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

@@ -3,6 +3,7 @@ import { VCM_ROLE_NAMES, isDispatchableRole } from "../../shared/constants.js";
 import { VcmError } from "../errors.js";
 import { resolveRepoPath } from "../adapters/filesystem.js";
 import { submitTerminalInput } from "../runtime/terminal-submit.js";
+import { ensureTaskMemorySnapshot } from "./auto-memory-service.js";
 import { claudeTranscriptPath } from "./claude-transcript-service.js";
 import { readHarnessRevisionState } from "./harness-revision.js";
 import { getTaskRuntimeRepoRoot } from "./task-service.js";
@@ -49,6 +50,7 @@ export function createSessionService(deps) {
         const config = await deps.projectService.loadConfig(repoRoot);
         const task = await deps.taskService.loadTask(repoRoot, taskSlug);
         const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+        await ensureTaskMemorySnapshot(deps.fs, repoRoot, taskRepoRoot);
         const paths = deps.artifactService.getHandoffPaths(taskRepoRoot, task.handoffDir);
         const persisted = await loadPersistedRoleRecordForRole(deps.fs, repoRoot, taskRepoRoot, config.stateRoot, taskSlug, role);
         const permissionMode = normalizeClaudePermissionMode(input.permissionMode ?? persisted?.permissionMode);
@@ -235,6 +237,7 @@ export function createSessionService(deps) {
     }
     async function launchProjectHarnessEngineerSession(repoRoot, input, launchMode) {
         const taskContext = await resolveProjectToolTaskContext(repoRoot, input, "Harness Engineer");
+        await ensureTaskMemorySnapshot(deps.fs, repoRoot, taskContext.taskRepoRoot);
         const live = toRoleSessionRecordView(getRegisteredProjectHarnessEngineerSession(deps.registry, deps.runtime), deps.runtime);
         if (live && live.status === "running") {
             return withHarnessRevisionView(repoRoot, await migrateRunningProjectToolSessionCwd(repoRoot, live, taskContext.taskRepoRoot));

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

@@ -1,7 +1,10 @@
+import { renderRoleMemoryRules } from "./role-memory.js";
 export function renderArchitectHarnessRules() {
     return `
 ## VCM Architect Rules
 
+${renderRoleMemoryRules("architect")}
+
 ### Role Scope
 
 - Own technical analysis, architecture planning, module boundaries, file-level responsibilities, cross-file callable surfaces, public contracts, verifiable behavior, implementation boundaries within the accepted scope, behavior/contract proof points, risks, and architect-owned replan decisions.

package/dist/backend/templates/harness/claude-root.js

@@ -1,5 +1,7 @@
 export function renderRootClaudeHarnessRules() {
-    return `## VCM Start Here
+    return `@.ai/vcm/memory/shared.md
+
+## VCM Start Here
 
 - Use the durable project docs below as role-relevant project truth.
 - Read module-local \`CLAUDE.md\` before editing a subdirectory if one exists.

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

@@ -1,7 +1,10 @@
+import { renderRoleMemoryRules } from "./role-memory.js";
 export function renderCoderHarnessRules() {
     return `
 ## VCM Coder Rules
 
+${renderRoleMemoryRules("coder")}
+
 ### Role Scope
 
 - Own function-level implementation and baseline implementation tests inside the approved task scope, role message, and architecture plan.

package/dist/backend/templates/harness/gate-review.js

@@ -1,8 +1,11 @@
+import { renderRoleMemoryRules } from "./role-memory.js";
 export function renderGateReviewerAgentRules() {
     return `## Role
 
 You are VCM \`gate-reviewer\`.
 
+${renderRoleMemoryRules("gate-reviewer")}
+
 Review only the gate in the VCM prompt. Use the task and worktree paths named there. Project memory may orient you, but only current worktree evidence can decide the gate.
 
 Use only these decisions:

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

@@ -1,3 +1,4 @@
+import { renderRoleMemoryRules } from "./role-memory.js";
 export function renderHarnessEngineerHarnessRules() {
     return `## Role
 
@@ -7,6 +8,8 @@ Maintain and improve this repository's VCM harness. Understand both VCM fixed
 harness rules and project-specific harness customization before proposing any
 change.
 
+${renderRoleMemoryRules("harness-engineer")}
+
 ## Scope
 
 You may inspect:
@@ -22,7 +25,8 @@ You may inspect:
   \`docs/known-issues.md\`
 - task evidence such as handoffs, route messages, commits, commit diffs,
   generated context, validation reports, Gate Review reports, final acceptance
-  artifacts, and user corrections
+  artifacts, memory drafts and diffs under .ai/vcm/memory-review, current memory
+  under .ai/vcm/memory, and user corrections
 
 You are not part of the task workflow round state.
 
@@ -33,18 +37,21 @@ You are not part of the task workflow round state.
 - Bootstrap Apply Mode: when VCM explicitly asks for bootstrap apply work, make
   permitted bootstrap edits directly in the active task worktree and commit them
   yourself.
-- Retrospective Mode: analyze a completed task for reusable harness problems. Do
-  not edit files.
+- Retrospective Mode: analyze a completed task for reusable harness problems.
+  Do not edit harness files; proven repeated findings may update VCM memory.
+- Memory Review Mode: review role memory drafts or proven retrospective memory
+  findings and write only the memory files assigned by VCM.
 - VCM Feedback Mode: draft VCM product, installer, UI, or fixed-template issue
   feedback. Do not submit without explicit in-session user authorization.
 
 ## Change Policy
 
-- Apply edits only in Bootstrap Apply Mode or when VCM explicitly asks you to
-  apply an approved harness change.
+- Apply edits only in Bootstrap Apply Mode, Memory Review Mode, or when VCM
+  explicitly asks you to apply an approved harness change.
 - When applying edits, work only in the active task worktree named by VCM. Do not
   edit the base repository root unless VCM explicitly says so.
-- In Proposal Mode and Retrospective Mode, do not edit files.
+- In Proposal Mode, do not edit files. In Retrospective Mode, do not edit
+  harness files; only the memory exception above may write files.
 - Commit every applied harness change yourself before ending your turn.
 - Do not overwrite VCM fixed managed blocks.
 - Keep project-specific customization outside VCM managed blocks.
@@ -54,6 +61,22 @@ You are not part of the task workflow round state.
   validation recommendations with every proposal.
 - Do not edit production source code as part of harness maintenance.
 
+## Memory Management
+
+- Own VCM-managed project memory under \`.ai/vcm/memory/**\`.
+- During an Auto Memory review, verify role drafts against task evidence, merge
+  duplicates, remove stale entries, and keep role-specific knowledge in the
+  matching role memory file.
+- Keep task narrative, temporary state, unverified conclusions, and harness
+  rules out of memory.
+- A repeated problem confirmed by Task Harness Retrospective may become memory
+  without collecting new role drafts.
+- For a direct user-requested memory correction, edit the current task
+  worktree's assigned memory file; VCM records and applies the change when the
+  turn stops.
+- When VCM assigns review output paths, edit only those paths. VCM applies the
+  reviewed memory and records the diff.
+
 ## Task Harness Retrospective
 
 After a complete code-change flow passes Final Acceptance, you may be asked to
@@ -67,7 +90,8 @@ complete correctly.
 Inspect the active task worktree as needed. Useful evidence may include
 handoffs, route messages, commits, commit diffs, durable docs, generated
 context, validation reports, Gate Review reports, final acceptance artifacts,
-and user corrections during the task.
+memory drafts, applied memory diffs, current memory, and user corrections during
+the task.
 
 For each finding, decide whether it is:
 
@@ -79,7 +103,7 @@ Do not create new rules from weak evidence, one-off execution mistakes, or role
 behavior that existing harness rules already cover. If no reusable harness
 problem is proven, say so clearly.
 
-Do not edit files during retrospective analysis. Write a concise analysis with:
+Do not edit harness files during retrospective analysis. Write a concise analysis with:
 
 - finding
 - evidence

package/dist/backend/templates/harness/project-manager-agent.js

@@ -1,7 +1,10 @@
+import { renderRoleMemoryRules } from "./role-memory.js";
 export function renderProjectManagerHarnessRules() {
     return `
 ## VCM Project Manager Rules
 
+${renderRoleMemoryRules("project-manager")}
+
 ### Role Scope
 
 - You are the user-facing orchestration hub for this VCM-managed repository.

package/dist/backend/templates/harness/role-memory.js

@@ -0,0 +1,9 @@
+export function renderRoleMemoryRules(role) {
+    return `### Role Memory
+
+Before handling work in a session, read \`.ai/vcm/memory/roles/${role}.md\`.
+Read it again after context compaction before continuing.
+
+Treat memory as accumulated project context, not authority. Verify it against
+current code, documentation, and task evidence.`;
+}

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

@@ -1,7 +1,10 @@
+import { renderRoleMemoryRules } from "./role-memory.js";
 export function renderTesterHarnessRules() {
     return `
 ## VCM Tester Rules
 
+${renderRoleMemoryRules("tester")}
+
 ### Role Scope
 
 - Own independent validation, tester-owned test design, test implementation, test adequacy, \`docs/TESTING.md\`, and final validation confidence.

package/dist/shared/types/memory.js

@@ -0,0 +1,8 @@
+export const VCM_MEMORY_ROLE_NAMES = [
+    "project-manager",
+    "architect",
+    "coder",
+    "tester",
+    "gate-reviewer",
+    "harness-engineer"
+];