vibe-coding-master 0.6.22 → 0.7.0

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

@@ -118,61 +118,130 @@ export function createTaskService(deps) {
             await this.saveTask(repoRoot, updated);
             return updated;
         },
-        async cleanupTask(repoRoot, taskSlug, options = {}) {
-            assertValidTaskSlug(taskSlug);
-            if (!deps.fs.removePath) {
-                throw new VcmError({
-                    code: "FILESYSTEM_REMOVE_UNAVAILABLE",
-                    message: "This VCM runtime cannot remove task files.",
-                    statusCode: 500
-                });
-            }
-            const config = await deps.projectService.loadConfig(repoRoot);
+        async markTaskCleaned(repoRoot, taskSlug) {
             const task = await this.loadTask(repoRoot, taskSlug);
+            if (task.cleanupStatus === "cleaned" && task.cleanedAt) {
+                return task;
+            }
+            const timestamp = now();
+            const updated = {
+                ...task,
+                status: "stopped",
+                cleanupStatus: "cleaned",
+                cleanedAt: timestamp,
+                updatedAt: timestamp
+            };
+            await this.saveTask(repoRoot, updated);
+            return updated;
+        },
+        async cleanupTask(repoRoot, taskSlug) {
+            assertValidTaskSlug(taskSlug);
+            const task = await this.markTaskCleaned(repoRoot, taskSlug);
             const taskRepoRoot = getTaskRuntimeRepoRoot(task);
             const taskStoreRoot = deps.projectService.getProjectDataRoot(repoRoot);
             const taskPath = getTaskPath(taskStoreRoot, taskSlug);
-            const statePaths = getTaskStatePaths(taskStoreRoot, taskRepoRoot, config.stateRoot, config.handoffRoot, taskSlug);
-            const removedStatePaths = [];
             const warnings = [];
-            const cleanedAt = now();
-            assertTaskWorktreePath(repoRoot, task.worktreePath);
-            await removeTaskWorktreeIdempotent(deps.fs, deps.git, repoRoot, task.worktreePath, options.force ?? true, warnings);
-            await deleteTaskBranchIdempotent(deps.git, repoRoot, task.branch, options.forceDeleteBranch ?? true);
+            if (!deps.fs.removePath) {
+                warnings.push("This VCM runtime cannot remove task files; the task remains logically closed.");
+            }
+            let stateRoot = ".ai/vcm";
+            let handoffRoot = task.handoffDir;
+            try {
+                const config = await deps.projectService.loadConfig(repoRoot);
+                stateRoot = config.stateRoot;
+                handoffRoot = config.handoffRoot;
+            }
+            catch (error) {
+                warnings.push(`Unable to load project cleanup paths; using task defaults: ${describeError(error)}`);
+            }
+            const statePaths = getTaskStatePaths(taskStoreRoot, taskRepoRoot, stateRoot, handoffRoot, taskSlug);
+            const removedStatePaths = [];
+            let worktreeRemoved = false;
+            try {
+                assertTaskWorktreePath(repoRoot, task.worktreePath);
+                worktreeRemoved = await removeTaskWorktreeBestEffort(deps.fs, deps.git, repoRoot, task.worktreePath, warnings);
+            }
+            catch (error) {
+                warnings.push(`Skipped unsafe task worktree path ${task.worktreePath}: ${describeError(error)}`);
+            }
+            const branchCleanup = await deleteTaskBranchBestEffort(deps.git, repoRoot, task.branch, warnings);
             for (const statePath of statePaths.filter((candidate) => candidate !== taskPath)) {
                 await removeWorktreeStatePathBestEffort(deps.fs, statePath, removedStatePaths, warnings);
             }
-            await deps.fs.removePath(taskPath, { recursive: true, force: true });
-            removedStatePaths.push(taskPath);
+            let stateRemoved = false;
+            if (worktreeRemoved && branchCleanup.resolved) {
+                try {
+                    await deps.fs.removePath?.(taskPath, { recursive: true, force: true });
+                    stateRemoved = !(await deps.fs.pathExists(taskPath));
+                    if (stateRemoved) {
+                        removedStatePaths.push(taskPath);
+                    }
+                    else {
+                        warnings.push(`Task state remained after cleanup: ${taskPath}`);
+                    }
+                }
+                catch (error) {
+                    warnings.push(`Unable to remove cleaned task state ${taskPath}: ${describeError(error)}`);
+                }
+            }
+            else {
+                warnings.push("Retained cleaned task state so unresolved resource cleanup can be retried later.");
+            }
             return {
                 taskSlug,
-                removedWorktreePath: task.worktreePath,
+                taskClosed: true,
+                worktreeRemoved,
+                branchDeleted: branchCleanup.resolved,
+                stateRemoved,
+                removedWorktreePath: worktreeRemoved ? task.worktreePath : null,
                 removedStatePaths,
-                deletedBranch: task.branch,
-                cleanedAt,
+                deletedBranch: branchCleanup.deleted ? task.branch : null,
+                cleanedAt: task.cleanedAt ?? now(),
                 warnings: warnings.length > 0 ? warnings : undefined
             };
         }
     };
 }
-async function removeTaskWorktreeIdempotent(fs, git, repoRoot, worktreePath, force, warnings) {
-    const wasRegistered = await git.isWorktreeRegistered(repoRoot, worktreePath);
-    if (wasRegistered) {
+async function removeTaskWorktreeBestEffort(fs, git, repoRoot, worktreePath, warnings) {
+    let wasRegistered;
+    try {
+        wasRegistered = await git.isWorktreeRegistered(repoRoot, worktreePath);
+    }
+    catch (error) {
+        warnings.push(`Unable to inspect task worktree registration for ${worktreePath}: ${describeError(error)}`);
+    }
+    if (wasRegistered !== false) {
         try {
-            await git.removeWorktree(repoRoot, worktreePath, { force });
+            await git.removeWorktree(repoRoot, worktreePath, { force: true });
         }
         catch (error) {
             await pruneWorktreesBestEffort(git, repoRoot, warnings);
-            if (await git.isWorktreeRegistered(repoRoot, worktreePath)) {
-                throw error;
+            let stillRegistered = true;
+            try {
+                stillRegistered = await git.isWorktreeRegistered(repoRoot, worktreePath);
+            }
+            catch (inspectionError) {
+                warnings.push(`Unable to verify task worktree registration after forced removal: ${describeError(inspectionError)}`);
+            }
+            if (stillRegistered) {
+                warnings.push(`Unable to force-remove Git worktree ${worktreePath}: ${describeError(error)}`);
+            }
+            else {
+                warnings.push(`Git worktree metadata was already cleared for ${worktreePath}; continuing cleanup.`);
             }
-            warnings.push(`Git worktree metadata was already cleared for ${worktreePath}; continuing cleanup.`);
         }
     }
     else {
         await pruneWorktreesBestEffort(git, repoRoot, warnings);
     }
-    if (await fs.pathExists(worktreePath)) {
+    let staleDirectoryExists = true;
+    try {
+        staleDirectoryExists = await fs.pathExists(worktreePath);
+    }
+    catch (error) {
+        warnings.push(`Unable to inspect stale task worktree directory ${worktreePath}: ${describeError(error)}`);
+    }
+    if (staleDirectoryExists) {
         try {
             await fs.removePath?.(worktreePath, { recursive: true, force: true });
         }
@@ -180,19 +249,67 @@ async function removeTaskWorktreeIdempotent(fs, git, repoRoot, worktreePath, for
             warnings.push(`Unable to remove stale task worktree directory ${worktreePath}: ${describeError(error)}`);
         }
     }
+    let pathExists = true;
+    let registered = true;
+    try {
+        pathExists = await fs.pathExists(worktreePath);
+    }
+    catch (error) {
+        warnings.push(`Unable to verify task worktree directory cleanup: ${describeError(error)}`);
+    }
+    try {
+        registered = await git.isWorktreeRegistered(repoRoot, worktreePath);
+    }
+    catch (error) {
+        warnings.push(`Unable to verify task worktree metadata cleanup: ${describeError(error)}`);
+    }
+    return !pathExists && !registered;
 }
-async function deleteTaskBranchIdempotent(git, repoRoot, branch, force) {
-    if (!(await git.branchExists(repoRoot, branch))) {
-        return;
+async function deleteTaskBranchBestEffort(git, repoRoot, branch, warnings) {
+    let branchExists;
+    try {
+        branchExists = await git.branchExists(repoRoot, branch);
+    }
+    catch (error) {
+        warnings.push(`Unable to inspect task branch ${branch}: ${describeError(error)}`);
     }
+    if (branchExists === false) {
+        return { resolved: true, deleted: false };
+    }
+    await warnAboutDiscardedCommits(git, repoRoot, branch, warnings);
     try {
-        await git.deleteBranch(repoRoot, branch, { force });
+        await git.deleteBranch(repoRoot, branch, { force: true });
+        return { resolved: true, deleted: true };
     }
     catch (error) {
-        if (!(await git.branchExists(repoRoot, branch))) {
+        try {
+            if (!(await git.branchExists(repoRoot, branch))) {
+                return { resolved: true, deleted: true };
+            }
+        }
+        catch (inspectionError) {
+            warnings.push(`Unable to verify task branch cleanup for ${branch}: ${describeError(inspectionError)}`);
+        }
+        warnings.push(`Unable to force-delete task branch ${branch}: ${describeError(error)}`);
+        return { resolved: false, deleted: false };
+    }
+}
+async function warnAboutDiscardedCommits(git, repoRoot, branch, warnings) {
+    try {
+        const baseBranch = await git.getCurrentBranch(repoRoot);
+        const commits = await git.getCommitList(repoRoot, `${baseBranch}..${branch}`);
+        if (commits.length === 0) {
             return;
         }
-        throw error;
+        const summary = commits
+            .slice(0, 5)
+            .map((commit) => `${commit.sha.slice(0, 8)} ${commit.subject}`)
+            .join("; ");
+        const remainder = commits.length > 5 ? `; and ${commits.length - 5} more` : "";
+        warnings.push(`${branch} has ${commits.length} commit(s) not contained in ${baseBranch}; close force-deletes the branch: ${summary}${remainder}`);
+    }
+    catch (error) {
+        warnings.push(`Unable to inspect commits before force-deleting ${branch}: ${describeError(error)}`);
     }
 }
 async function pruneWorktreesBestEffort(git, repoRoot, warnings) {

package/dist/backend/services/turn-reconciler-service.js

@@ -0,0 +1,122 @@
+import { readTranscriptTurnEvidence } from "./claude-transcript-reply.js";
+import { getTaskRuntimeRepoRoot } from "./task-service.js";
+export const TURN_STALL_THRESHOLD_MS = 30 * 60_000;
+export const TURN_INTERRUPT_GRACE_MS = 10_000;
+export function createTurnReconcilerService(deps) {
+    const now = deps.now ?? (() => new Date().toISOString());
+    const stallThresholdMs = deps.stallThresholdMs ?? TURN_STALL_THRESHOLD_MS;
+    const interruptGraceMs = deps.interruptGraceMs ?? TURN_INTERRUPT_GRACE_MS;
+    const readEvidence = deps.readTranscriptEvidence ?? readTranscriptTurnEvidence;
+    const pendingInterrupts = new Map();
+    return {
+        async reconcileTask(repoRoot, task, stateRoot) {
+            const taskRepoRoot = getTaskRuntimeRepoRoot(task);
+            const round = await deps.roundService.getSessionRoundState({
+                repoRoot,
+                stateRepoRoot: taskRepoRoot,
+                stateRoot,
+                taskSlug: task.taskSlug
+            });
+            if (round.status !== "running"
+                || !round.activeRole
+                || !round.activeTurnStartedAt
+                || round.roleRecovery) {
+                clearTaskInterrupts(repoRoot, task.taskSlug);
+                return { status: "inactive" };
+            }
+            const role = round.activeRole;
+            const interruptKey = `${repoRoot}:${task.taskSlug}:${role}`;
+            const session = await deps.sessionService.getRoleSession(repoRoot, task.taskSlug, role);
+            const evidence = session
+                ? await readEvidence({ ...session, lastTurnStartedAt: round.activeTurnStartedAt })
+                : {};
+            if (evidence.completion) {
+                pendingInterrupts.delete(interruptKey);
+                await deps.claudeHookService.handleReconciledTurnEnd(buildReconciledHook(task.taskSlug, role, session, "Stop", {
+                    vcm_reconcile_reason: "transcript-end-turn",
+                    vcm_completion_id: evidence.completion.id,
+                    vcm_completion_at: evidence.completion.timestamp
+                }));
+                return { status: "completed", role, reason: "transcript-end-turn" };
+            }
+            if (!session || session.status !== "running") {
+                pendingInterrupts.delete(interruptKey);
+                const reason = session ? "terminal-session-exited" : "terminal-session-missing";
+                await deps.claudeHookService.handleReconciledTurnEnd(buildReconciledHook(task.taskSlug, role, session, "StopFailure", {
+                    error: reason.replaceAll("-", "_"),
+                    error_details: `VCM reconciled an active turn because its ${reason.replaceAll("-", " ")}.`
+                }));
+                return { status: "failed", role, reason };
+            }
+            const lastActivityAt = latestTimestamp([
+                round.activeTurnStartedAt,
+                session.lastHookEventAt,
+                session.lastOutputAt,
+                evidence.lastActivityAt
+            ]);
+            const currentTime = now();
+            if (!isStale(lastActivityAt, currentTime, stallThresholdMs)) {
+                pendingInterrupts.delete(interruptKey);
+                return { status: "active" };
+            }
+            const pendingInterrupt = pendingInterrupts.get(interruptKey);
+            if (!pendingInterrupt || pendingInterrupt.turnStartedAt !== round.activeTurnStartedAt) {
+                deps.runtime.write(session.id, "\u0003");
+                pendingInterrupts.set(interruptKey, {
+                    turnStartedAt: round.activeTurnStartedAt,
+                    requestedAt: currentTime
+                });
+                return { status: "active" };
+            }
+            if (!isStale(pendingInterrupt.requestedAt, currentTime, interruptGraceMs)) {
+                return { status: "active" };
+            }
+            pendingInterrupts.delete(interruptKey);
+            await deps.claudeHookService.handleReconciledTurnEnd(buildReconciledHook(task.taskSlug, role, session, "StopFailure", {
+                error: "turn_stalled",
+                error_details: `No hook, terminal output, or transcript activity was observed for ${stallThresholdMs}ms.`
+            }));
+            return { status: "failed", role, reason: "turn-stalled" };
+        }
+    };
+    function clearTaskInterrupts(repoRoot, taskSlug) {
+        for (const key of pendingInterrupts.keys()) {
+            if (key.startsWith(`${repoRoot}:${taskSlug}:`)) {
+                pendingInterrupts.delete(key);
+            }
+        }
+    }
+}
+function buildReconciledHook(taskSlug, role, session, eventName, evidence) {
+    return {
+        taskSlug,
+        role,
+        event: {
+            hook_event_name: eventName,
+            ...(session?.claudeSessionId ? { session_id: session.claudeSessionId } : {}),
+            ...(session?.transcriptPath ? { transcript_path: session.transcriptPath } : {}),
+            ...(session?.cwd ? { cwd: session.cwd } : {}),
+            vcm_reconciled: true,
+            ...evidence
+        }
+    };
+}
+function latestTimestamp(values) {
+    return values.reduce((latest, value) => {
+        if (!value) {
+            return latest;
+        }
+        const valueMs = Date.parse(value);
+        const latestMs = latest ? Date.parse(latest) : Number.NaN;
+        return Number.isFinite(valueMs) && (!Number.isFinite(latestMs) || valueMs > latestMs)
+            ? value
+            : latest;
+    }, undefined);
+}
+function isStale(lastActivityAt, currentTime, thresholdMs) {
+    const activityMs = lastActivityAt ? Date.parse(lastActivityAt) : Number.NaN;
+    const currentMs = Date.parse(currentTime);
+    return Number.isFinite(activityMs)
+        && Number.isFinite(currentMs)
+        && currentMs - activityMs >= thresholdMs;
+}

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"
+];