@mandipadk7/kavi 0.1.1 → 0.1.3

package/dist/daemon.js

@@ -1,12 +1,18 @@
+import fs from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
 import { consumeCommands } from "./command-queue.js";
 import { buildPeerMessages as buildClaudePeerMessages, runClaudeTask } from "./adapters/claude.js";
 import { buildPeerMessages as buildCodexPeerMessages, runCodexTask } from "./adapters/codex.js";
+import { buildDecisionReplay } from "./adapters/shared.js";
+import { listApprovalRequests, resolveApprovalRequest } from "./approvals.js";
 import { addDecisionRecord, upsertPathClaim } from "./decision-ledger.js";
-import { listWorktreeChangedPaths } from "./git.js";
+import { getWorktreeDiffReview, listWorktreeChangedPaths } from "./git.js";
 import { nowIso } from "./paths.js";
+import { addReviewReply, addReviewNote, autoResolveReviewNotesForCompletedTask, linkReviewFollowUpTask, reviewNotesForTask, setReviewNoteStatus, updateReviewNote } from "./reviews.js";
 import { buildAdHocTask, buildKickoffTasks } from "./router.js";
-import { loadSessionRecord, recordEvent, saveSessionRecord } from "./session.js";
-import { saveTaskArtifact } from "./task-artifacts.js";
+import { loadSessionRecord, readRecentEvents, recordEvent, saveSessionRecord } from "./session.js";
+import { loadTaskArtifact, saveTaskArtifact } from "./task-artifacts.js";
 export class KaviDaemon {
     paths;
     session;
@@ -15,6 +21,10 @@ export class KaviDaemon {
     processing = false;
     interval = null;
     stopResolver = null;
+    rpcServer = null;
+    clients = new Set();
+    subscribers = new Set();
+    mutationQueue = Promise.resolve();
     constructor(paths){
         this.paths = paths;
     }
@@ -28,6 +38,7 @@ export class KaviDaemon {
         await recordEvent(this.paths, this.session.id, "daemon.started", {
             daemonPid: process.pid
         });
+        await this.startRpcServer();
         this.running = true;
         void this.tick();
         this.interval = setInterval(()=>{
@@ -37,6 +48,636 @@ export class KaviDaemon {
             this.stopResolver = resolve;
         });
     }
+    async startRpcServer() {
+        await fs.mkdir(path.dirname(this.paths.socketPath), {
+            recursive: true
+        });
+        await fs.rm(this.paths.socketPath, {
+            force: true
+        }).catch(()=>{});
+        this.rpcServer = net.createServer((socket)=>{
+            this.clients.add(socket);
+            socket.setEncoding("utf8");
+            let buffer = "";
+            socket.on("data", (chunk)=>{
+                buffer += chunk;
+                while(true){
+                    const newlineIndex = buffer.indexOf("\n");
+                    if (newlineIndex === -1) {
+                        return;
+                    }
+                    const line = buffer.slice(0, newlineIndex).trim();
+                    buffer = buffer.slice(newlineIndex + 1);
+                    if (!line) {
+                        continue;
+                    }
+                    let request;
+                    try {
+                        request = JSON.parse(line);
+                    } catch (error) {
+                        this.writeRpc(socket, {
+                            id: "parse-error",
+                            error: {
+                                message: error instanceof Error ? error.message : "Unable to parse RPC payload."
+                            }
+                        });
+                        continue;
+                    }
+                    void this.handleRpcRequest(socket, request);
+                }
+            });
+            const cleanup = ()=>{
+                this.clients.delete(socket);
+                this.subscribers.delete(socket);
+            };
+            socket.on("error", cleanup);
+            socket.on("close", cleanup);
+        });
+        await new Promise((resolve, reject)=>{
+            this.rpcServer?.once("error", reject);
+            this.rpcServer?.listen(this.paths.socketPath, ()=>{
+                this.rpcServer?.off("error", reject);
+                resolve();
+            });
+        });
+    }
+    writeRpc(socket, response, onWritten) {
+        socket.write(`${JSON.stringify(response)}\n`, onWritten);
+    }
+    writeNotification(socket, notification) {
+        socket.write(`${JSON.stringify(notification)}\n`);
+    }
+    async handleRpcRequest(socket, request) {
+        try {
+            const dispatch = await this.dispatchRpc(socket, request.method, request.params ?? {});
+            this.writeRpc(socket, {
+                id: request.id,
+                result: dispatch.result
+            }, ()=>{
+                if (dispatch.shutdownAfterResponse) {
+                    void this.stopFromRpc();
+                }
+            });
+        } catch (error) {
+            this.writeRpc(socket, {
+                id: request.id,
+                error: {
+                    message: error instanceof Error ? error.message : String(error)
+                }
+            });
+        }
+    }
+    async dispatchRpc(socket, method, params) {
+        switch(method){
+            case "ping":
+                return {
+                    result: {
+                        ok: true,
+                        sessionId: this.session.id
+                    }
+                };
+            case "snapshot":
+                return {
+                    result: await this.buildSnapshot()
+                };
+            case "subscribe":
+                this.subscribers.add(socket);
+                return {
+                    result: await this.buildSnapshot()
+                };
+            case "kickoff":
+                await this.kickoffFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "enqueueTask":
+                await this.enqueueRpcTask(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "shutdown":
+                return {
+                    result: {
+                        ok: true
+                    },
+                    shutdownAfterResponse: true
+                };
+            case "resolveApproval":
+                await this.resolveApprovalFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "taskArtifact":
+                return {
+                    result: await this.getTaskArtifactFromRpc(params)
+                };
+            case "events":
+                return {
+                    result: await this.getEventsFromRpc(params)
+                };
+            case "worktreeDiff":
+                return {
+                    result: await this.getWorktreeDiffFromRpc(params)
+                };
+            case "notifyExternalUpdate":
+                await this.publishSnapshot(typeof params.reason === "string" && params.reason.trim() ? params.reason.trim() : "external.update");
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "addReviewNote":
+                await this.addReviewNoteFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "updateReviewNote":
+                await this.updateReviewNoteFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "addReviewReply":
+                await this.addReviewReplyFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "setReviewNoteStatus":
+                await this.setReviewNoteStatusFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "enqueueReviewFollowUp":
+                await this.enqueueReviewFollowUpFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            default:
+                throw new Error(`Unknown RPC method: ${method}`);
+        }
+    }
+    async buildSnapshot() {
+        const session = await loadSessionRecord(this.paths);
+        const events = await readRecentEvents(this.paths, 30);
+        const approvals = await listApprovalRequests(this.paths, {
+            includeResolved: true
+        });
+        const worktreeDiffs = await Promise.all(session.worktrees.map(async (worktree)=>({
+                agent: worktree.agent,
+                paths: await listWorktreeChangedPaths(worktree.path, session.baseCommit).catch(()=>[])
+            })));
+        return {
+            session,
+            events,
+            approvals,
+            worktreeDiffs
+        };
+    }
+    async runMutation(fn) {
+        const previous = this.mutationQueue;
+        let release = ()=>{};
+        this.mutationQueue = new Promise((resolve)=>{
+            release = resolve;
+        });
+        await previous;
+        try {
+            return await fn();
+        } finally{
+            release();
+        }
+    }
+    async enqueueRpcTask(params) {
+        await this.runMutation(async ()=>{
+            const prompt = typeof params.prompt === "string" ? params.prompt : "";
+            if (!prompt.trim()) {
+                throw new Error("enqueueTask requires a prompt.");
+            }
+            const owner = params.owner === "claude" ? "claude" : "codex";
+            const commandId = `rpc-${Date.now()}`;
+            const taskId = `task-${commandId}`;
+            const task = buildAdHocTask(owner, prompt, taskId, {
+                routeReason: typeof params.routeReason === "string" ? params.routeReason : null,
+                claimedPaths: Array.isArray(params.claimedPaths) ? params.claimedPaths.map((item)=>String(item)) : []
+            });
+            this.session.tasks.push(task);
+            addDecisionRecord(this.session, {
+                kind: "route",
+                agent: owner,
+                taskId,
+                summary: `Routed task to ${owner}`,
+                detail: typeof params.routeReason === "string" ? params.routeReason : `Task enqueued for ${owner}.`,
+                metadata: {
+                    strategy: typeof params.routeStrategy === "string" ? params.routeStrategy : "unknown",
+                    confidence: typeof params.routeConfidence === "number" ? params.routeConfidence : null,
+                    claimedPaths: task.claimedPaths
+                }
+            });
+            upsertPathClaim(this.session, {
+                taskId,
+                agent: owner,
+                source: "route",
+                paths: task.claimedPaths,
+                note: task.routeReason
+            });
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "task.enqueued", {
+                owner,
+                via: "rpc"
+            });
+            await this.publishSnapshot("task.enqueued");
+        });
+    }
+    async kickoffFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const prompt = typeof params.prompt === "string" ? params.prompt : "";
+            if (!prompt.trim()) {
+                throw new Error("kickoff requires a prompt.");
+            }
+            this.session.goal = prompt;
+            this.session.tasks.push(...buildKickoffTasks(prompt));
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "tasks.kickoff_enqueued", {
+                count: 2,
+                via: "rpc"
+            });
+            await this.publishSnapshot("tasks.kickoff_enqueued");
+        });
+    }
+    async stopFromRpc() {
+        await this.runMutation(async ()=>{
+            this.session.status = "stopped";
+            this.running = false;
+            this.session.daemonHeartbeatAt = new Date().toISOString();
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "daemon.stopped", {
+                via: "rpc"
+            });
+            if (this.interval) {
+                clearInterval(this.interval);
+                this.interval = null;
+            }
+            await this.closeRpcServer();
+            this.stopResolver?.();
+        });
+    }
+    async resolveApprovalFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const requestId = typeof params.requestId === "string" ? params.requestId : "";
+            const decision = params.decision === "deny" ? "deny" : "allow";
+            const remember = params.remember === true;
+            if (!requestId) {
+                throw new Error("resolveApproval requires a requestId.");
+            }
+            const request = await resolveApprovalRequest(this.paths, requestId, decision, remember);
+            addDecisionRecord(this.session, {
+                kind: "approval",
+                agent: request.agent,
+                summary: `${decision === "allow" ? "Approved" : "Denied"} ${request.toolName}`,
+                detail: request.summary,
+                metadata: {
+                    requestId: request.id,
+                    remember,
+                    toolName: request.toolName
+                }
+            });
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "approval.resolved", {
+                requestId: request.id,
+                decision,
+                remember,
+                agent: request.agent,
+                toolName: request.toolName,
+                via: "rpc"
+            });
+            await this.publishSnapshot("approval.resolved");
+        });
+    }
+    async getTaskArtifactFromRpc(params) {
+        const taskId = typeof params.taskId === "string" ? params.taskId : "";
+        if (!taskId) {
+            throw new Error("taskArtifact requires a taskId.");
+        }
+        return await loadTaskArtifact(this.paths, taskId);
+    }
+    async getEventsFromRpc(params) {
+        const limit = typeof params.limit === "number" && Number.isFinite(params.limit) ? params.limit : 20;
+        return await readRecentEvents(this.paths, limit);
+    }
+    async getWorktreeDiffFromRpc(params) {
+        const agent = params.agent === "claude" ? "claude" : "codex";
+        const filePath = typeof params.filePath === "string" ? params.filePath : null;
+        const worktree = this.session.worktrees.find((item)=>item.agent === agent);
+        if (!worktree) {
+            throw new Error(`No managed worktree found for ${agent}.`);
+        }
+        return await getWorktreeDiffReview(agent, worktree.path, this.session.baseCommit, filePath);
+    }
+    async addReviewNoteFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const agent = params.agent === "claude" ? "claude" : "codex";
+            const filePath = typeof params.filePath === "string" ? params.filePath.trim() : "";
+            const disposition = params.disposition === "approve" || params.disposition === "concern" || params.disposition === "question" ? params.disposition : "note";
+            const body = typeof params.body === "string" ? params.body.trim() : "";
+            const taskId = typeof params.taskId === "string" ? params.taskId : null;
+            const hunkIndex = typeof params.hunkIndex === "number" ? params.hunkIndex : null;
+            const hunkHeader = typeof params.hunkHeader === "string" ? params.hunkHeader : null;
+            if (!filePath) {
+                throw new Error("addReviewNote requires a filePath.");
+            }
+            if (!body) {
+                throw new Error("addReviewNote requires a note body.");
+            }
+            const note = addReviewNote(this.session, {
+                agent,
+                taskId,
+                filePath,
+                hunkIndex,
+                hunkHeader,
+                disposition,
+                body
+            });
+            addDecisionRecord(this.session, {
+                kind: "review",
+                agent,
+                taskId,
+                summary: note.summary,
+                detail: note.body,
+                metadata: {
+                    filePath: note.filePath,
+                    hunkIndex: note.hunkIndex,
+                    hunkHeader: note.hunkHeader,
+                    disposition: note.disposition,
+                    reviewNoteId: note.id
+                }
+            });
+            await saveSessionRecord(this.paths, this.session);
+            if (taskId) {
+                await this.refreshTaskArtifactReviewNotes(taskId);
+            }
+            await recordEvent(this.paths, this.session.id, "review.note_added", {
+                reviewNoteId: note.id,
+                agent: note.agent,
+                taskId: note.taskId,
+                filePath: note.filePath,
+                hunkIndex: note.hunkIndex,
+                disposition: note.disposition
+            });
+            await this.publishSnapshot("review.note_added");
+        });
+    }
+    async updateReviewNoteFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const noteId = typeof params.noteId === "string" ? params.noteId : "";
+            const body = typeof params.body === "string" ? params.body.trim() : "";
+            if (!noteId) {
+                throw new Error("updateReviewNote requires a noteId.");
+            }
+            if (!body) {
+                throw new Error("updateReviewNote requires a note body.");
+            }
+            const note = updateReviewNote(this.session, noteId, {
+                body
+            });
+            if (!note) {
+                throw new Error(`Review note ${noteId} was not found.`);
+            }
+            addDecisionRecord(this.session, {
+                kind: "review",
+                agent: note.agent,
+                taskId: note.taskId,
+                summary: `Edited review note ${note.id}`,
+                detail: note.body,
+                metadata: {
+                    reviewNoteId: note.id,
+                    filePath: note.filePath,
+                    hunkIndex: note.hunkIndex
+                }
+            });
+            await saveSessionRecord(this.paths, this.session);
+            if (note.taskId) {
+                await this.refreshTaskArtifactReviewNotes(note.taskId);
+            }
+            await recordEvent(this.paths, this.session.id, "review.note_updated", {
+                reviewNoteId: note.id,
+                taskId: note.taskId,
+                agent: note.agent,
+                filePath: note.filePath
+            });
+            await this.publishSnapshot("review.note_updated");
+        });
+    }
+    async addReviewReplyFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const noteId = typeof params.noteId === "string" ? params.noteId : "";
+            const body = typeof params.body === "string" ? params.body.trim() : "";
+            if (!noteId) {
+                throw new Error("addReviewReply requires a noteId.");
+            }
+            if (!body) {
+                throw new Error("addReviewReply requires a reply body.");
+            }
+            const note = addReviewReply(this.session, noteId, body);
+            if (!note) {
+                throw new Error(`Review note ${noteId} was not found.`);
+            }
+            addDecisionRecord(this.session, {
+                kind: "review",
+                agent: note.agent,
+                taskId: note.taskId,
+                summary: `Replied to review note ${note.id}`,
+                detail: body,
+                metadata: {
+                    reviewNoteId: note.id,
+                    filePath: note.filePath,
+                    hunkIndex: note.hunkIndex,
+                    replyCount: note.comments.length
+                }
+            });
+            await saveSessionRecord(this.paths, this.session);
+            if (note.taskId) {
+                await this.refreshTaskArtifactReviewNotes(note.taskId);
+            }
+            await recordEvent(this.paths, this.session.id, "review.reply_added", {
+                reviewNoteId: note.id,
+                taskId: note.taskId,
+                agent: note.agent,
+                filePath: note.filePath,
+                replyCount: note.comments.length
+            });
+            await this.publishSnapshot("review.reply_added");
+        });
+    }
+    async setReviewNoteStatusFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const noteId = typeof params.noteId === "string" ? params.noteId : "";
+            const status = params.status === "resolved" ? "resolved" : "open";
+            if (!noteId) {
+                throw new Error("setReviewNoteStatus requires a noteId.");
+            }
+            const note = setReviewNoteStatus(this.session, noteId, status);
+            if (!note) {
+                throw new Error(`Review note ${noteId} was not found.`);
+            }
+            addDecisionRecord(this.session, {
+                kind: "review",
+                agent: note.agent,
+                taskId: note.taskId,
+                summary: `${status === "resolved" ? "Resolved" : "Reopened"} review note ${note.id}`,
+                detail: note.summary,
+                metadata: {
+                    reviewNoteId: note.id,
+                    status,
+                    filePath: note.filePath,
+                    hunkIndex: note.hunkIndex
+                }
+            });
+            await saveSessionRecord(this.paths, this.session);
+            if (note.taskId) {
+                await this.refreshTaskArtifactReviewNotes(note.taskId);
+            }
+            await recordEvent(this.paths, this.session.id, "review.note_status_changed", {
+                reviewNoteId: note.id,
+                taskId: note.taskId,
+                agent: note.agent,
+                filePath: note.filePath,
+                status: note.status
+            });
+            await this.publishSnapshot("review.note_status_changed");
+        });
+    }
+    async enqueueReviewFollowUpFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const noteId = typeof params.noteId === "string" ? params.noteId : "";
+            const owner = params.owner === "claude" ? "claude" : "codex";
+            const mode = params.mode === "handoff" ? "handoff" : "fix";
+            if (!noteId) {
+                throw new Error("enqueueReviewFollowUp requires a noteId.");
+            }
+            const note = this.session.reviewNotes.find((item)=>item.id === noteId) ?? null;
+            if (!note) {
+                throw new Error(`Review note ${noteId} was not found.`);
+            }
+            const taskId = `task-review-${Date.now()}`;
+            const scope = note.hunkHeader ? `${note.filePath} ${note.hunkHeader}` : note.filePath;
+            const promptLines = [
+                `${mode === "handoff" ? "Handle a review handoff" : "Address a review note"} for ${scope}.`,
+                `Disposition: ${note.disposition}.`,
+                `Review note: ${note.body}`
+            ];
+            if (note.taskId) {
+                promptLines.push(`Originating task: ${note.taskId}.`);
+            }
+            if (mode === "handoff") {
+                promptLines.push(`This was handed off from ${note.agent} work to ${owner}.`);
+            }
+            promptLines.push(`Focus the change in ${note.filePath} and update the managed worktree accordingly.`);
+            const task = buildAdHocTask(owner, promptLines.join(" "), taskId, {
+                routeReason: mode === "handoff" ? `Operator handed off review note ${note.id} to ${owner}.` : `Operator created a follow-up task from review note ${note.id}.`,
+                claimedPaths: [
+                    note.filePath
+                ]
+            });
+            this.session.tasks.push(task);
+            linkReviewFollowUpTask(this.session, note.id, taskId);
+            upsertPathClaim(this.session, {
+                taskId,
+                agent: owner,
+                source: "route",
+                paths: task.claimedPaths,
+                note: task.routeReason
+            });
+            addDecisionRecord(this.session, {
+                kind: "review",
+                agent: owner,
+                taskId,
+                summary: `Queued ${mode} follow-up from review note ${note.id}`,
+                detail: note.body,
+                metadata: {
+                    reviewNoteId: note.id,
+                    owner,
+                    mode,
+                    filePath: note.filePath,
+                    sourceAgent: note.agent
+                }
+            });
+            await saveSessionRecord(this.paths, this.session);
+            if (note.taskId) {
+                await this.refreshTaskArtifactReviewNotes(note.taskId);
+            }
+            await recordEvent(this.paths, this.session.id, "review.followup_queued", {
+                reviewNoteId: note.id,
+                followUpTaskId: taskId,
+                owner,
+                mode,
+                filePath: note.filePath
+            });
+            await this.publishSnapshot("review.followup_queued");
+        });
+    }
+    async refreshTaskArtifactReviewNotes(taskId) {
+        const artifact = await loadTaskArtifact(this.paths, taskId);
+        if (!artifact) {
+            return;
+        }
+        artifact.reviewNotes = reviewNotesForTask(this.session, taskId);
+        await saveTaskArtifact(this.paths, artifact);
+    }
+    async refreshReviewArtifactsForNotes(notes) {
+        const taskIds = [
+            ...new Set(notes.map((note)=>note.taskId).filter((value)=>Boolean(value)))
+        ];
+        for (const taskId of taskIds){
+            await this.refreshTaskArtifactReviewNotes(taskId);
+        }
+    }
+    async publishSnapshot(reason) {
+        if (this.subscribers.size === 0) {
+            return;
+        }
+        const snapshot = await this.buildSnapshot();
+        const notification = {
+            method: "snapshot.updated",
+            params: {
+                reason,
+                snapshot
+            }
+        };
+        for (const subscriber of this.subscribers){
+            this.writeNotification(subscriber, notification);
+        }
+    }
+    async closeRpcServer() {
+        const server = this.rpcServer;
+        this.rpcServer = null;
+        for (const client of this.clients){
+            client.end();
+        }
+        this.clients.clear();
+        this.subscribers.clear();
+        if (server) {
+            await new Promise((resolve)=>{
+                server.close(()=>resolve());
+            });
+        }
+        await fs.rm(this.paths.socketPath, {
+            force: true
+        }).catch(()=>{});
+    }
     async tick() {
         if (!this.running || this.processing) {
             return;
@@ -50,6 +691,7 @@ export class KaviDaemon {
                     clearInterval(this.interval);
                     this.interval = null;
                 }
+                await this.closeRpcServer();
                 this.stopResolver?.();
                 return;
             }
@@ -64,6 +706,7 @@ export class KaviDaemon {
                 await recordEvent(this.paths, this.session.id, "tasks.kickoff_created", {
                     count: this.session.tasks.length
                 });
+                await this.publishSnapshot("tasks.kickoff_created");
             }
             const pending = this.session.tasks.filter((task)=>task.status === "pending");
             for (const task of pending){
@@ -89,6 +732,7 @@ export class KaviDaemon {
                     clearInterval(this.interval);
                     this.interval = null;
                 }
+                await this.closeRpcServer();
                 this.stopResolver?.();
                 return;
             }
@@ -99,6 +743,7 @@ export class KaviDaemon {
                 await recordEvent(this.paths, this.session.id, "tasks.kickoff_enqueued", {
                     count: 2
                 });
+                await this.publishSnapshot("tasks.kickoff_enqueued");
                 continue;
             }
             if (command.type === "enqueue" && typeof command.payload.prompt === "string") {
@@ -132,6 +777,7 @@ export class KaviDaemon {
                 await recordEvent(this.paths, this.session.id, "task.enqueued", {
                     owner
                 });
+                await this.publishSnapshot("task.enqueued");
             }
         }
     }
@@ -144,6 +790,7 @@ export class KaviDaemon {
             taskId: task.id,
             owner: task.owner
         });
+        await this.publishSnapshot("task.started");
         try {
             let envelope;
             let peerMessages;
@@ -159,7 +806,7 @@ export class KaviDaemon {
                 envelope = result.envelope;
                 rawOutput = result.raw;
                 peerMessages = buildClaudePeerMessages(result.envelope, "claude", task.id);
-                await this.markAgent("claude", result.envelope.summary, 0, `${this.session.id}-claude`);
+                await this.markAgent("claude", result.envelope.summary, 0, result.sessionId);
             } else {
                 throw new Error(`Unsupported task owner ${task.owner}.`);
             }
@@ -192,8 +839,25 @@ export class KaviDaemon {
                     claimedPaths: task.claimedPaths
                 }
             });
+            const autoResolvedNotes = autoResolveReviewNotesForCompletedTask(this.session, task.id);
+            for (const note of autoResolvedNotes){
+                addDecisionRecord(this.session, {
+                    kind: "review",
+                    agent: note.agent,
+                    taskId: note.taskId,
+                    summary: `Auto-resolved review note ${note.id}`,
+                    detail: `Closed because linked follow-up task ${task.id} completed successfully.`,
+                    metadata: {
+                        reviewNoteId: note.id,
+                        filePath: note.filePath,
+                        followUpTaskId: task.id,
+                        reason: "follow-up-task-completed"
+                    }
+                });
+            }
             this.session.peerMessages.push(...peerMessages);
             await saveSessionRecord(this.paths, this.session);
+            const decisionReplay = buildDecisionReplay(this.session, task, task.owner === "claude" ? "claude" : "codex");
             await saveTaskArtifact(this.paths, {
                 taskId: task.id,
                 sessionId: this.session.id,
@@ -201,18 +865,33 @@ export class KaviDaemon {
                 owner: task.owner,
                 status: task.status,
                 summary: task.summary,
+                routeReason: task.routeReason,
+                claimedPaths: task.claimedPaths,
+                decisionReplay,
                 rawOutput,
                 error: null,
                 envelope,
+                reviewNotes: reviewNotesForTask(this.session, task.id),
                 startedAt,
                 finishedAt: task.updatedAt
             });
+            await this.refreshReviewArtifactsForNotes(autoResolvedNotes);
             await recordEvent(this.paths, this.session.id, "task.completed", {
                 taskId: task.id,
                 owner: task.owner,
                 status: task.status,
                 peerMessages: peerMessages.length
             });
+            for (const note of autoResolvedNotes){
+                await recordEvent(this.paths, this.session.id, "review.note_auto_resolved", {
+                    reviewNoteId: note.id,
+                    taskId: note.taskId,
+                    followUpTaskId: task.id,
+                    agent: note.agent,
+                    filePath: note.filePath
+                });
+            }
+            await this.publishSnapshot("task.completed");
         } catch (error) {
             task.status = "failed";
             task.summary = error instanceof Error ? error.message : String(error);
@@ -245,6 +924,7 @@ export class KaviDaemon {
             });
             await this.markAgent(task.owner, task.summary, 1, task.owner === "claude" ? `${this.session.id}-claude` : null);
             await saveSessionRecord(this.paths, this.session);
+            const decisionReplay = buildDecisionReplay(this.session, task, task.owner === "claude" ? "claude" : "codex");
             await saveTaskArtifact(this.paths, {
                 taskId: task.id,
                 sessionId: this.session.id,
@@ -252,9 +932,13 @@ export class KaviDaemon {
                 owner: task.owner,
                 status: task.status,
                 summary: task.summary,
+                routeReason: task.routeReason,
+                claimedPaths: task.claimedPaths,
+                decisionReplay,
                 rawOutput: null,
                 error: task.summary,
                 envelope: null,
+                reviewNotes: reviewNotesForTask(this.session, task.id),
                 startedAt,
                 finishedAt: task.updatedAt
             });
@@ -263,6 +947,7 @@ export class KaviDaemon {
                 owner: task.owner,
                 error: task.summary
             });
+            await this.publishSnapshot("task.failed");
         }
     }
     async markAgent(agent, summary, exitCode, sessionId) {