vibe-coding-master 0.6.23 → 0.7.1

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/claude-root.js

@@ -8,6 +8,7 @@ export function renderRootClaudeHarnessRules() {
 - \`vcm-route-message\` is the only channel for PM-hub dispatch and reporting among project-manager, architect, coder, and tester. Gate Review and tool-role work use their dedicated VCM skills and controllers. Follow the route skill's write-then-stop rule.
 - Use \`vcm-long-running-validation\` for long-running validation. Follow the background job limits below.
 - Use \`vcm-report-harness-issue\` when you notice a reusable VCM harness problem. Record feedback; do not contact Harness Engineer directly.
+- Treat \`.ai/vcm/memory/**\` as read-only. Use \`vcm-propose-memory\` only when VCM assigns a memory proposal during Task Harness Review.
 - Project-manager runs \`vcm-gate-review\` unconditionally at every Gate Review trigger point and on VCM Gate Review callbacks; the tool reports the authoritative enable state.
 
 ## VCM Harness Scope

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

@@ -38,9 +38,10 @@ You are not part of the task workflow round state.
   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 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.
+  Do not edit harness or memory files.
+- Memory Review Mode: when Auto Memory is enabled and VCM starts the memory
+  phase of Task Harness Review, review role proposals and write only the review
+  output 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.
 
@@ -50,8 +51,7 @@ You are not part of the task workflow round state.
   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, do not edit files. In Retrospective Mode, do not edit
-  harness files; only the memory exception above may write files.
+- In Proposal Mode and Retrospective Mode, do not edit 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.
@@ -64,18 +64,16 @@ You are not part of the task workflow round state.
 ## 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.
+- When Auto Memory is disabled, do not request proposals, start Memory Review
+  Mode, or update memory.
+- During VCM-assigned Memory Review, verify every role proposal against task
+  evidence, merge duplicates, remove stale entries, and keep role-specific
+  knowledge in the matching role memory file.
+- Do not record task narrative, temporary state, unverified conclusions, or
+  Harness rules in memory.
+- Edit only the review output paths assigned by VCM. Do not edit
+  \`.ai/vcm/memory/**\` directly. VCM applies the reviewed output and records the
+  diff.
 
 ## Task Harness Retrospective
 

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

@@ -1,9 +1,19 @@
 export function renderRoleMemoryRules(role) {
+    const proposalRule = role === "harness-engineer"
+        ? `Treat \`.ai/vcm/memory/**\` as read-only during role turns. Update memory
+only through VCM-assigned Memory Review output paths or explicit user edits in
+Harness Studio. When Auto Memory is disabled, do not initiate memory proposals,
+reviews, or updates.`
+        : `Treat \`.ai/vcm/memory/**\` as read-only. Do not create, edit, or delete
+memory files. Only when VCM explicitly requests a proposal during Task Harness
+Review, use \`vcm-propose-memory\` and write the exact assigned draft path.`;
     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.`;
+current code, documentation, and task evidence.
+
+${proposalRule}`;
 }

package/dist/backend/templates/harness/vcm-propose-memory-skill.js

@@ -0,0 +1,35 @@
+export function renderVcmProposeMemorySkillRules() {
+    return `Use this skill only when VCM explicitly requests a memory proposal during Task
+Harness Review and provides an exact draft path.
+
+## Rules
+
+- Treat \`.ai/vcm/memory/**\` as read-only. This skill creates a proposal; it
+  never edits active memory.
+- Write only to the exact draft path assigned by VCM. The path must be under
+  \`.ai/vcm/memory-review/runs/<run-id>/drafts/\` in the active task worktree.
+- If VCM did not provide a draft path, do not create a proposal.
+- Propose only verified, durable, reusable project knowledge supported by task
+  evidence.
+- Do not record task narrative, temporary state, unverified conclusions, or
+  Harness rules.
+- Do not edit handoff artifacts or route messages from this skill.
+
+## Draft Format
+
+\`\`\`markdown
+# Memory Proposal
+Decision: update | no-change
+
+## Add
+
+## Update
+
+## Remove
+
+## Evidence
+\`\`\`
+
+Use \`Decision: no-change\` when the completed task produced no qualifying
+memory. End the turn after writing the assigned draft.`;
+}