@mandipadk7/kavi 0.1.1 → 0.1.3

package/dist/main.js

@@ -9,13 +9,15 @@ import { KaviDaemon } from "./daemon.js";
 import { addDecisionRecord, upsertPathClaim } from "./decision-ledger.js";
 import { runDoctor } from "./doctor.js";
 import { writeJson } from "./fs.js";
-import { createGitignoreEntries, detectRepoRoot, ensureWorktrees, findOverlappingWorktreePaths, getHeadCommit, landBranches, resolveTargetBranch } from "./git.js";
+import { createGitignoreEntries, detectRepoRoot, ensureBootstrapCommit, ensureGitRepository, ensureWorktrees, findRepoRoot, findOverlappingWorktreePaths, landBranches, resolveTargetBranch } from "./git.js";
 import { buildSessionId, resolveAppPaths } from "./paths.js";
 import { isProcessAlive, spawnDetachedNode } from "./process.js";
+import { pingRpc, readSnapshot, rpcEnqueueTask, rpcNotifyExternalUpdate, rpcKickoff, rpcRecentEvents, rpcResolveApproval, rpcShutdown, rpcTaskArtifact } from "./rpc.js";
+import { markReviewNotesLandedForTasks } from "./reviews.js";
 import { resolveSessionRuntime } from "./runtime.js";
 import { buildAdHocTask, extractPromptPathHints, routeTask } from "./router.js";
-import { createSessionRecord, loadSessionRecord, readRecentEvents, recordEvent, sessionExists, sessionHeartbeatAgeMs } from "./session.js";
-import { listTaskArtifacts, loadTaskArtifact } from "./task-artifacts.js";
+import { createSessionRecord, loadSessionRecord, readRecentEvents, recordEvent, saveSessionRecord, sessionExists, sessionHeartbeatAgeMs } from "./session.js";
+import { listTaskArtifacts, loadTaskArtifact, saveTaskArtifact } from "./task-artifacts.js";
 import { attachTui } from "./tui.js";
 const HEARTBEAT_STALE_MS = 10_000;
 const CLAUDE_AUTO_ALLOW_TOOLS = new Set([
@@ -58,7 +60,7 @@ async function readStdinText() {
 function renderUsage() {
     return [
         "Usage:",
-        "  kavi init [--home]",
+        "  kavi init [--home] [--no-commit]",
         "  kavi doctor [--json]",
         "  kavi start [--goal \"...\"]",
         "  kavi open [--goal \"...\"]",
@@ -68,6 +70,9 @@ function renderUsage() {
         "  kavi task [--agent codex|claude|auto] <prompt>",
         "  kavi tasks [--json]",
         "  kavi task-output <task-id|latest> [--json]",
+        "  kavi decisions [--json] [--limit N]",
+        "  kavi claims [--json] [--all]",
+        "  kavi reviews [--json] [--all]",
         "  kavi approvals [--json] [--all]",
         "  kavi approve <request-id|latest> [--remember]",
         "  kavi deny <request-id|latest> [--remember]",
@@ -96,7 +101,7 @@ async function waitForSession(paths, expectedState = "running") {
         try {
             if (await sessionExists(paths)) {
                 const session = await loadSessionRecord(paths);
-                if (expectedState === "running" && isSessionLive(session)) {
+                if (expectedState === "running" && isSessionLive(session) && await pingRpc(paths)) {
                     return;
                 }
                 if (expectedState === "stopped" && session.status === "stopped") {
@@ -108,22 +113,65 @@ async function waitForSession(paths, expectedState = "running") {
     }
     throw new Error(`Timed out waiting for session state ${expectedState} in ${paths.stateFile}.`);
 }
-async function commandInit(cwd, args) {
-    const repoRoot = await detectRepoRoot(cwd);
+async function prepareProjectContext(cwd, options) {
+    let repoRoot;
+    let createdRepository = false;
+    let hasGitRepository = false;
+    if (options.createRepository) {
+        const repository = await ensureGitRepository(cwd);
+        repoRoot = repository.repoRoot;
+        createdRepository = repository.createdRepository;
+        hasGitRepository = true;
+    } else {
+        const existingRepoRoot = await findRepoRoot(cwd);
+        repoRoot = existingRepoRoot ?? cwd;
+        hasGitRepository = existingRepoRoot !== null;
+    }
     const paths = resolveAppPaths(repoRoot);
     await ensureProjectScaffold(paths);
-    await createGitignoreEntries(repoRoot);
-    if (args.includes("--home")) {
+    if (hasGitRepository) {
+        await createGitignoreEntries(repoRoot);
+    }
+    if (options.ensureHomeConfig) {
         await ensureHomeConfig(paths);
-        console.log(`Initialized user-local Kavi config in ${paths.homeConfigFile}`);
     }
-    console.log(`Initialized Kavi project scaffold in ${paths.kaviDir}`);
+    return {
+        repoRoot,
+        paths,
+        createdRepository,
+        bootstrapCommit: options.ensureHeadCommit ? await ensureBootstrapCommit(repoRoot) : null
+    };
+}
+async function commandInit(cwd, args) {
+    const skipCommit = args.includes("--no-commit");
+    const prepared = await prepareProjectContext(cwd, {
+        createRepository: true,
+        ensureHeadCommit: !skipCommit,
+        ensureHomeConfig: args.includes("--home")
+    });
+    if (args.includes("--home")) {
+        console.log(`Initialized user-local Kavi config in ${prepared.paths.homeConfigFile}`);
+    }
+    if (prepared.createdRepository) {
+        console.log(`Initialized git repository in ${prepared.repoRoot}`);
+    }
+    console.log(`Initialized Kavi project scaffold in ${prepared.paths.kaviDir}`);
+    if (skipCommit) {
+        console.log("Skipped bootstrap commit creation (--no-commit).");
+        console.log('Kavi will create the first base commit automatically on "kavi open" or "kavi start".');
+        return;
+    }
+    if (prepared.bootstrapCommit?.createdCommit) {
+        console.log(`Created bootstrap commit ${prepared.bootstrapCommit.commit.slice(0, 12)} with ${prepared.bootstrapCommit.stagedPaths.length} tracked path${prepared.bootstrapCommit.stagedPaths.length === 1 ? "" : "s"}.`);
+    }
 }
 async function commandDoctor(cwd, args) {
-    const repoRoot = await detectRepoRoot(cwd);
-    const paths = resolveAppPaths(repoRoot);
-    await ensureProjectScaffold(paths);
-    const checks = await runDoctor(repoRoot, paths);
+    const prepared = await prepareProjectContext(cwd, {
+        createRepository: false,
+        ensureHeadCommit: false,
+        ensureHomeConfig: false
+    });
+    const checks = await runDoctor(prepared.repoRoot, prepared.paths);
     if (args.includes("--json")) {
         console.log(JSON.stringify(checks, null, 2));
         process.exitCode = checks.some((check)=>!check.ok) ? 1 : 0;
@@ -139,20 +187,18 @@ async function commandDoctor(cwd, args) {
     process.exitCode = failed ? 1 : 0;
 }
 async function startOrAttachSession(cwd, goal) {
-    const repoRoot = await detectRepoRoot(cwd);
-    const paths = resolveAppPaths(repoRoot);
-    await ensureProjectScaffold(paths);
-    await createGitignoreEntries(repoRoot);
-    await ensureHomeConfig(paths);
-    await ensureStartupReady(repoRoot, paths);
+    const prepared = await prepareProjectContext(cwd, {
+        createRepository: true,
+        ensureHeadCommit: false,
+        ensureHomeConfig: true
+    });
+    const { repoRoot, paths } = prepared;
     if (await sessionExists(paths)) {
         try {
             const session = await loadSessionRecord(paths);
-            if (isSessionLive(session)) {
+            if (isSessionLive(session) && await pingRpc(paths)) {
                 if (goal) {
-                    await appendCommand(paths, "kickoff", {
-                        prompt: goal
-                    });
+                    await rpcKickoff(paths, goal);
                 }
                 return session.socketPath;
             }
@@ -162,14 +208,27 @@ async function startOrAttachSession(cwd, goal) {
             });
         } catch  {}
     }
+    await ensureStartupReady(repoRoot, paths);
     const config = await loadConfig(paths);
     const runtime = await resolveSessionRuntime(paths);
-    const baseCommit = await getHeadCommit(repoRoot);
+    const bootstrapCommit = await ensureBootstrapCommit(repoRoot);
+    const baseCommit = bootstrapCommit.commit;
     const sessionId = buildSessionId();
-    const rpcEndpoint = "file://session-state";
+    const rpcEndpoint = paths.socketPath;
     await fs.writeFile(paths.commandsFile, "", "utf8");
     const worktrees = await ensureWorktrees(repoRoot, paths, sessionId, config, baseCommit);
     await createSessionRecord(paths, config, runtime, sessionId, baseCommit, worktrees, goal, rpcEndpoint);
+    if (prepared.createdRepository) {
+        await recordEvent(paths, sessionId, "repo.initialized", {
+            repoRoot
+        });
+    }
+    if (bootstrapCommit.createdCommit) {
+        await recordEvent(paths, sessionId, "repo.bootstrap_committed", {
+            commit: bootstrapCommit.commit,
+            stagedPaths: bootstrapCommit.stagedPaths
+        });
+    }
     const pid = spawnDetachedNode(runtime.nodeExecutable, [
         fileURLToPath(import.meta.url),
         "__daemon",
@@ -210,6 +269,20 @@ async function requireSession(cwd) {
         paths
     };
 }
+async function tryRpcSnapshot(paths) {
+    if (!await pingRpc(paths)) {
+        return null;
+    }
+    return await readSnapshot(paths);
+}
+async function notifyOperatorSurface(paths, reason) {
+    if (!await pingRpc(paths)) {
+        return;
+    }
+    try {
+        await rpcNotifyExternalUpdate(paths, reason);
+    } catch  {}
+}
 async function commandOpen(cwd, args) {
     const goal = getGoal(args);
     await startOrAttachSession(cwd, goal);
@@ -224,8 +297,8 @@ async function commandResume(cwd) {
 }
 async function commandStart(cwd, args) {
     const goal = getGoal(args);
-    const repoRoot = await detectRepoRoot(cwd);
     const socketPath = await startOrAttachSession(cwd, goal);
+    const repoRoot = await detectRepoRoot(cwd);
     const paths = resolveAppPaths(repoRoot);
     const session = await loadSessionRecord(paths);
     console.log(`Started Kavi session ${session.id}`);
@@ -238,17 +311,20 @@ async function commandStart(cwd, args) {
 }
 async function commandStatus(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const session = await loadSessionRecord(paths);
-    const pendingApprovals = await listApprovalRequests(paths);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
+    const pendingApprovals = rpcSnapshot?.approvals.filter((item)=>item.status === "pending") ?? await listApprovalRequests(paths);
     const heartbeatAgeMs = sessionHeartbeatAgeMs(session);
     const payload = {
         id: session.id,
         status: session.status,
         repoRoot: session.repoRoot,
+        socketPath: session.socketPath,
         goal: session.goal,
         daemonPid: session.daemonPid,
         daemonHeartbeatAt: session.daemonHeartbeatAt,
         daemonHealthy: isSessionLive(session),
+        rpcConnected: rpcSnapshot !== null,
         heartbeatAgeMs,
         runtime: session.runtime,
         taskCounts: {
@@ -265,6 +341,10 @@ async function commandStatus(cwd, args) {
         decisionCounts: {
             total: session.decisions.length
         },
+        reviewCounts: {
+            open: session.reviewNotes.filter((note)=>note.status === "open").length,
+            total: session.reviewNotes.length
+        },
         pathClaimCounts: {
             active: session.pathClaims.filter((claim)=>claim.status === "active").length
         },
@@ -277,12 +357,14 @@ async function commandStatus(cwd, args) {
     console.log(`Session: ${payload.id}`);
     console.log(`Status: ${payload.status}${payload.daemonHealthy ? " (healthy)" : " (stale or stopped)"}`);
     console.log(`Repo: ${payload.repoRoot}`);
+    console.log(`Control: ${payload.socketPath}${payload.rpcConnected ? " (connected)" : " (disconnected)"}`);
     console.log(`Goal: ${payload.goal ?? "-"}`);
     console.log(`Daemon PID: ${payload.daemonPid ?? "-"}`);
     console.log(`Heartbeat: ${payload.daemonHeartbeatAt ?? "-"}${heartbeatAgeMs === null ? "" : ` (${heartbeatAgeMs} ms ago)`}`);
     console.log(`Runtime: node=${payload.runtime.nodeExecutable} codex=${payload.runtime.codexExecutable} claude=${payload.runtime.claudeExecutable}`);
     console.log(`Tasks: total=${payload.taskCounts.total} pending=${payload.taskCounts.pending} running=${payload.taskCounts.running} blocked=${payload.taskCounts.blocked} completed=${payload.taskCounts.completed} failed=${payload.taskCounts.failed}`);
     console.log(`Approvals: pending=${payload.approvalCounts.pending}`);
+    console.log(`Reviews: open=${payload.reviewCounts.open} total=${payload.reviewCounts.total}`);
     console.log(`Decisions: total=${payload.decisionCounts.total}`);
     console.log(`Path claims: active=${payload.pathClaimCounts.active}`);
     for (const worktree of payload.worktrees){
@@ -290,7 +372,7 @@ async function commandStatus(cwd, args) {
     }
 }
 async function commandPaths(cwd, args) {
-    const repoRoot = await detectRepoRoot(cwd);
+    const repoRoot = await findRepoRoot(cwd) ?? cwd;
     const paths = resolveAppPaths(repoRoot);
     const runtime = await resolveSessionRuntime(paths);
     const payload = {
@@ -305,6 +387,7 @@ async function commandPaths(cwd, args) {
         eventsFile: paths.eventsFile,
         approvalsFile: paths.approvalsFile,
         commandsFile: paths.commandsFile,
+        socketPath: paths.socketPath,
         runsDir: paths.runsDir,
         claudeSettingsFile: paths.claudeSettingsFile,
         homeApprovalRulesFile: paths.homeApprovalRulesFile,
@@ -325,6 +408,7 @@ async function commandPaths(cwd, args) {
     console.log(`Events file: ${payload.eventsFile}`);
     console.log(`Approvals file: ${payload.approvalsFile}`);
     console.log(`Command queue: ${payload.commandsFile}`);
+    console.log(`Control socket: ${payload.socketPath}`);
     console.log(`Task artifacts: ${payload.runsDir}`);
     console.log(`Claude settings: ${payload.claudeSettingsFile}`);
     console.log(`Approval rules: ${payload.homeApprovalRulesFile}`);
@@ -332,7 +416,8 @@ async function commandPaths(cwd, args) {
 }
 async function commandTask(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const session = await loadSessionRecord(paths);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
     const requestedAgent = getFlag(args, "--agent");
     const prompt = getGoal(args.filter((arg, index)=>arg !== "--agent" && args[index - 1] !== "--agent"));
     if (!prompt) {
@@ -345,14 +430,25 @@ async function commandTask(cwd, args) {
         reason: `User explicitly assigned the task to ${requestedAgent}.`,
         claimedPaths: extractPromptPathHints(prompt)
     } : await routeTask(prompt, session, paths);
-    await appendCommand(paths, "enqueue", {
-        owner: routeDecision.owner,
-        prompt,
-        routeReason: routeDecision.reason,
-        claimedPaths: routeDecision.claimedPaths,
-        routeStrategy: routeDecision.strategy,
-        routeConfidence: routeDecision.confidence
-    });
+    if (rpcSnapshot) {
+        await rpcEnqueueTask(paths, {
+            owner: routeDecision.owner,
+            prompt,
+            routeReason: routeDecision.reason,
+            claimedPaths: routeDecision.claimedPaths,
+            routeStrategy: routeDecision.strategy,
+            routeConfidence: routeDecision.confidence
+        });
+    } else {
+        await appendCommand(paths, "enqueue", {
+            owner: routeDecision.owner,
+            prompt,
+            routeReason: routeDecision.reason,
+            claimedPaths: routeDecision.claimedPaths,
+            routeStrategy: routeDecision.strategy,
+            routeConfidence: routeDecision.confidence
+        });
+    }
     await recordEvent(paths, session.id, "task.cli_enqueued", {
         owner: routeDecision.owner,
         prompt,
@@ -364,7 +460,8 @@ async function commandTask(cwd, args) {
 }
 async function commandTasks(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const session = await loadSessionRecord(paths);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
     const artifacts = await listTaskArtifacts(paths);
     const artifactMap = new Map(artifacts.map((artifact)=>[
             artifact.taskId,
@@ -411,12 +508,13 @@ function resolveRequestedTaskId(args, knownTaskIds) {
 }
 async function commandTaskOutput(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const session = await loadSessionRecord(paths);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
     const sortedTasks = [
         ...session.tasks
     ].sort((left, right)=>left.updatedAt.localeCompare(right.updatedAt));
     const taskId = resolveRequestedTaskId(args, sortedTasks.map((task)=>task.id));
-    const artifact = await loadTaskArtifact(paths, taskId);
+    const artifact = rpcSnapshot ? await rpcTaskArtifact(paths, taskId) : await loadTaskArtifact(paths, taskId);
     if (!artifact) {
         throw new Error(`No task artifact found for ${taskId}.`);
     }
@@ -430,15 +528,104 @@ async function commandTaskOutput(cwd, args) {
     console.log(`Started: ${artifact.startedAt}`);
     console.log(`Finished: ${artifact.finishedAt}`);
     console.log(`Summary: ${artifact.summary ?? "-"}`);
+    console.log(`Route: ${artifact.routeReason ?? "-"}`);
+    console.log(`Claimed paths: ${artifact.claimedPaths.join(", ") || "-"}`);
     console.log(`Error: ${artifact.error ?? "-"}`);
+    console.log("Decision Replay:");
+    for (const line of artifact.decisionReplay){
+        console.log(line);
+    }
     console.log("Envelope:");
     console.log(JSON.stringify(artifact.envelope, null, 2));
+    console.log("Review Notes:");
+    if (artifact.reviewNotes.length === 0) {
+        console.log("-");
+    } else {
+        for (const note of artifact.reviewNotes){
+            console.log(`${note.createdAt} | ${note.disposition} | ${note.status} | ${note.filePath}${note.hunkIndex === null ? "" : ` | hunk ${note.hunkIndex + 1}`}`);
+            console.log(`  comments: ${note.comments.length}`);
+            for (const [index, comment] of note.comments.entries()){
+                console.log(`  ${index === 0 ? "root" : `reply-${index}`}: ${comment.body}`);
+            }
+            console.log(`  landed: ${note.landedAt ?? "-"}`);
+            console.log(`  follow-ups: ${note.followUpTaskIds.join(", ") || "-"}`);
+        }
+    }
     console.log("Raw Output:");
     console.log(artifact.rawOutput ?? "");
 }
+async function commandDecisions(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
+    const limitArg = getFlag(args, "--limit");
+    const limit = limitArg ? Number(limitArg) : 20;
+    const decisions = [
+        ...session.decisions
+    ].sort((left, right)=>left.createdAt.localeCompare(right.createdAt)).slice(-Math.max(1, Number.isFinite(limit) ? limit : 20));
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(decisions, null, 2));
+        return;
+    }
+    if (decisions.length === 0) {
+        console.log("No decisions recorded.");
+        return;
+    }
+    for (const decision of decisions){
+        console.log(`${decision.createdAt} | ${decision.kind} | ${decision.agent ?? "-"} | ${decision.summary}`);
+        console.log(`  task: ${decision.taskId ?? "-"}`);
+        console.log(`  detail: ${decision.detail}`);
+    }
+}
+async function commandClaims(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
+    const claims = args.includes("--all") ? session.pathClaims : session.pathClaims.filter((claim)=>claim.status === "active");
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(claims, null, 2));
+        return;
+    }
+    if (claims.length === 0) {
+        console.log("No path claims recorded.");
+        return;
+    }
+    for (const claim of claims){
+        console.log(`${claim.id} | ${claim.agent} | ${claim.status} | ${claim.source} | ${claim.paths.join(", ") || "-"}`);
+        console.log(`  task: ${claim.taskId}`);
+        console.log(`  updated: ${claim.updatedAt}`);
+        console.log(`  note: ${claim.note ?? "-"}`);
+    }
+}
+async function commandReviews(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
+    const notes = args.includes("--all") ? [
+        ...session.reviewNotes
+    ] : session.reviewNotes.filter((note)=>note.status === "open");
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(notes, null, 2));
+        return;
+    }
+    if (notes.length === 0) {
+        console.log("No review notes recorded.");
+        return;
+    }
+    for (const note of notes){
+        console.log(`${note.id} | ${note.agent} | ${note.status} | ${note.disposition} | ${note.filePath}${note.hunkIndex === null ? "" : ` | hunk ${note.hunkIndex + 1}`}`);
+        console.log(`  task: ${note.taskId ?? "-"}`);
+        console.log(`  updated: ${note.updatedAt}`);
+        console.log(`  comments: ${note.comments.length}`);
+        console.log(`  landed: ${note.landedAt ?? "-"}`);
+        console.log(`  follow-ups: ${note.followUpTaskIds.join(", ") || "-"}`);
+        console.log(`  body: ${note.body}`);
+    }
+}
 async function commandApprovals(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const requests = await listApprovalRequests(paths, {
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const requests = rpcSnapshot ? rpcSnapshot.approvals.filter((request)=>args.includes("--all") || request.status === "pending") : await listApprovalRequests(paths, {
         includeResolved: args.includes("--all")
     });
     if (args.includes("--json")) {
@@ -469,40 +656,54 @@ function resolveApprovalRequestId(requests, requested) {
 }
 async function commandResolveApproval(cwd, args, decision) {
     const { paths } = await requireSession(cwd);
-    const requests = await listApprovalRequests(paths, {
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const requests = rpcSnapshot?.approvals ?? await listApprovalRequests(paths, {
         includeResolved: true
     });
     const requestedId = args.find((arg)=>!arg.startsWith("--")) ?? "latest";
     const requestId = resolveApprovalRequestId(requests, requestedId);
     const remember = args.includes("--remember");
-    const request = await resolveApprovalRequest(paths, requestId, decision, remember);
-    const session = await loadSessionRecord(paths);
-    addDecisionRecord(session, {
-        kind: "approval",
-        agent: request.agent,
-        summary: `${decision === "allow" ? "Approved" : "Denied"} ${request.toolName}`,
-        detail: request.summary,
-        metadata: {
-            requestId: request.id,
+    const request = requests.find((item)=>item.id === requestId);
+    if (!request) {
+        throw new Error(`Approval request ${requestId} not found.`);
+    }
+    if (rpcSnapshot) {
+        await rpcResolveApproval(paths, {
+            requestId,
+            decision,
+            remember
+        });
+    } else {
+        const resolved = await resolveApprovalRequest(paths, requestId, decision, remember);
+        const session = await loadSessionRecord(paths);
+        addDecisionRecord(session, {
+            kind: "approval",
+            agent: resolved.agent,
+            summary: `${decision === "allow" ? "Approved" : "Denied"} ${resolved.toolName}`,
+            detail: resolved.summary,
+            metadata: {
+                requestId: resolved.id,
+                remember,
+                toolName: resolved.toolName
+            }
+        });
+        await saveSessionRecord(paths, session);
+        await recordEvent(paths, session.id, "approval.resolved", {
+            requestId: resolved.id,
+            decision,
             remember,
-            toolName: request.toolName
-        }
-    });
-    await saveSessionRecord(paths, session);
-    await recordEvent(paths, session.id, "approval.resolved", {
-        requestId: request.id,
-        decision,
-        remember,
-        agent: request.agent,
-        toolName: request.toolName
-    });
+            agent: resolved.agent,
+            toolName: resolved.toolName
+        });
+    }
     console.log(`${decision === "allow" ? "Approved" : "Denied"} ${request.id}: ${request.summary}${remember ? " (remembered)" : ""}`);
 }
 async function commandEvents(cwd, args) {
     const { paths } = await requireSession(cwd);
     const limitArg = getFlag(args, "--limit");
     const limit = limitArg ? Number(limitArg) : 20;
-    const events = await readRecentEvents(paths, Number.isFinite(limit) ? limit : 20);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const events = rpcSnapshot ? await rpcRecentEvents(paths, Number.isFinite(limit) ? limit : 20) : await readRecentEvents(paths, Number.isFinite(limit) ? limit : 20);
     for (const event of events){
         console.log(`${event.timestamp} ${event.type} ${JSON.stringify(event.payload)}`);
     }
@@ -517,8 +718,12 @@ async function commandStop(cwd) {
         console.log(`Marked stale Kavi session ${session.id} as stopped`);
         return;
     }
-    await appendCommand(paths, "shutdown", {});
-    await recordEvent(paths, session.id, "daemon.stop_requested", {});
+    if (await pingRpc(paths)) {
+        await rpcShutdown(paths);
+    } else {
+        await appendCommand(paths, "shutdown", {});
+        await recordEvent(paths, session.id, "daemon.stop_requested", {});
+    }
     await waitForSession(paths, "stopped");
     console.log(`Stopped Kavi session ${session.id}`);
 }
@@ -580,6 +785,46 @@ async function commandLand(cwd) {
         snapshotCommits: result.snapshotCommits,
         commands: result.commandsRun
     });
+    const landedReviewNotes = markReviewNotesLandedForTasks(session, session.tasks.filter((task)=>task.status === "completed").map((task)=>task.id));
+    for (const note of landedReviewNotes){
+        addDecisionRecord(session, {
+            kind: "review",
+            agent: note.agent,
+            taskId: note.taskId,
+            summary: `Marked review note ${note.id} as landed`,
+            detail: `Follow-up work for ${note.filePath} is now part of ${targetBranch}.`,
+            metadata: {
+                reviewNoteId: note.id,
+                filePath: note.filePath,
+                landedAt: note.landedAt,
+                targetBranch
+            }
+        });
+        await recordEvent(paths, session.id, "review.note_landed", {
+            reviewNoteId: note.id,
+            taskId: note.taskId,
+            followUpTaskIds: note.followUpTaskIds,
+            agent: note.agent,
+            filePath: note.filePath,
+            landedAt: note.landedAt,
+            targetBranch
+        });
+    }
+    await saveSessionRecord(paths, session);
+    const artifactTaskIds = [
+        ...new Set(landedReviewNotes.flatMap((note)=>note.taskId ? [
+                note.taskId
+            ] : []))
+    ];
+    for (const taskId of artifactTaskIds){
+        const artifact = await loadTaskArtifact(paths, taskId);
+        if (!artifact) {
+            continue;
+        }
+        artifact.reviewNotes = session.reviewNotes.filter((note)=>note.taskId === taskId);
+        await saveTaskArtifact(paths, artifact);
+    }
+    await notifyOperatorSurface(paths, "land.completed");
     console.log(`Landed branches into ${targetBranch}`);
     console.log(`Integration branch: ${result.integrationBranch}`);
     console.log(`Integration worktree: ${result.integrationPath}`);
@@ -618,6 +863,7 @@ async function commandHook(args) {
                 toolName: descriptor.toolName,
                 summary: descriptor.summary
             });
+            await notifyOperatorSurface(paths, "approval.auto_allowed");
             console.log(JSON.stringify({
                 continue: true,
                 suppressOutput: true,
@@ -642,6 +888,7 @@ async function commandHook(args) {
                 decision: rule.decision,
                 summary: descriptor.summary
             });
+            await notifyOperatorSurface(paths, "approval.auto_decided");
             console.log(JSON.stringify({
                 continue: true,
                 suppressOutput: true,
@@ -666,6 +913,7 @@ async function commandHook(args) {
             toolName: request.toolName,
             summary: request.summary
         });
+        await notifyOperatorSurface(paths, "approval.requested");
         const resolved = await waitForApprovalDecision(paths, request.id);
         const approved = resolved?.status === "approved";
         const denied = resolved?.status === "denied";
@@ -674,6 +922,7 @@ async function commandHook(args) {
             requestId: request.id,
             outcome: approved ? "approved" : denied ? "denied" : "expired"
         });
+        await notifyOperatorSurface(paths, "approval.completed");
         console.log(JSON.stringify({
             continue: true,
             suppressOutput: true,
@@ -687,6 +936,7 @@ async function commandHook(args) {
     }
     if (session) {
         await recordEvent(paths, session.id, "claude.hook", hookPayload);
+        await notifyOperatorSurface(paths, "claude.hook");
     }
     console.log(JSON.stringify({
         continue: true
@@ -731,6 +981,15 @@ async function main() {
         case "task-output":
             await commandTaskOutput(cwd, args);
             break;
+        case "decisions":
+            await commandDecisions(cwd, args);
+            break;
+        case "claims":
+            await commandClaims(cwd, args);
+            break;
+        case "reviews":
+            await commandReviews(cwd, args);
+            break;
         case "approvals":
             await commandApprovals(cwd, args);
             break;

package/dist/paths.js

@@ -23,7 +23,7 @@ export function resolveAppPaths(repoRoot) {
         approvalsFile: path.join(stateDir, "approvals.json"),
         commandsFile: path.join(runtimeDir, "commands.jsonl"),
         claudeSettingsFile: path.join(runtimeDir, "claude.settings.json"),
-        socketPath: path.join(runtimeDir, "kavid.sock"),
+        socketPath: path.join(homeStateDir, "sockets", `${safeRepoId}.sock`),
         homeConfigDir,
         homeConfigFile: path.join(homeConfigDir, "config.toml"),
         homeApprovalRulesFile: path.join(homeConfigDir, "approval-rules.json"),