@mandipadk7/kavi 0.1.7 → 1.0.0

package/dist/main.js

@@ -10,12 +10,13 @@ import { KaviDaemon } from "./daemon.js";
 import { addDecisionRecord, buildClaimHotspots, releasePathClaims, upsertPathClaim } from "./decision-ledger.js";
 import { runDoctor } from "./doctor.js";
 import { writeJson } from "./fs.js";
-import { createGitignoreEntries, detectRepoRoot, ensureBootstrapCommit, ensureGitRepository, ensureWorktrees, findRepoRoot, findOverlappingWorktreePaths, landBranches, resolveTargetBranch } from "./git.js";
+import { createGitignoreEntries, detectRepoRoot, ensureBootstrapCommit, ensureGitRepository, ensureWorktrees, findRepoRoot, findOverlappingWorktreePaths, getBranchCommit, landBranches, listWorktreeChangedPaths, resolveTargetBranch } from "./git.js";
 import { loadPackageInfo } from "./package-info.js";
 import { buildSessionId, resolveAppPaths } from "./paths.js";
 import { isProcessAlive, runCommand, runInteractiveCommand, spawnDetachedNode } from "./process.js";
-import { pingRpc, readSnapshot, rpcEnqueueTask, rpcNotifyExternalUpdate, rpcKickoff, rpcRecentEvents, rpcResolveApproval, rpcShutdown, rpcTaskArtifact } from "./rpc.js";
-import { buildOperatorRecommendations } from "./recommendations.js";
+import { buildLandReport, loadLatestLandReport, saveLandReport } from "./reports.js";
+import { pingRpc, readSnapshot, rpcDismissRecommendation, rpcEnqueueTask, rpcNotifyExternalUpdate, rpcKickoff, rpcRecentEvents, rpcResolveApproval, rpcRestoreRecommendation, rpcShutdown, rpcTaskArtifact } from "./rpc.js";
+import { buildOperatorRecommendations, buildRecommendationActionPlan, dismissOperatorRecommendation, restoreOperatorRecommendation } from "./recommendations.js";
 import { findOwnershipRuleConflicts } from "./ownership.js";
 import { filterReviewNotes, markReviewNotesLandedForTasks } from "./reviews.js";
 import { resolveSessionRuntime } from "./runtime.js";
@@ -24,6 +25,7 @@ import { createSessionRecord, loadSessionRecord, readRecentEvents, recordEvent,
 import { listTaskArtifacts, loadTaskArtifact, saveTaskArtifact } from "./task-artifacts.js";
 import { attachTui } from "./tui.js";
 import { buildUpdatePlan, parseRegistryVersion } from "./update.js";
+import { buildWorkflowActivity, buildWorkflowResult, buildWorkflowSummary } from "./workflow.js";
 const HEARTBEAT_STALE_MS = 10_000;
 const CLAUDE_AUTO_ALLOW_TOOLS = new Set([
     "Read",
@@ -58,6 +60,24 @@ function getOptionalFilter(args, name) {
     }
     return value;
 }
+function parseRecommendationKind(value) {
+    if (!value) {
+        return null;
+    }
+    if (value === "all" || value === "handoff" || value === "integration" || value === "ownership-config") {
+        return value;
+    }
+    throw new Error(`Unsupported recommendation kind "${value}".`);
+}
+function parseRecommendationStatus(value) {
+    if (!value) {
+        return null;
+    }
+    if (value === "all" || value === "active" || value === "dismissed") {
+        return value;
+    }
+    throw new Error(`Unsupported recommendation status "${value}".`);
+}
 async function readStdinText() {
     if (process.stdin.isTTY) {
         return "";
@@ -95,13 +115,18 @@ function renderUsage() {
         "  kavi start [--goal \"...\"]",
         "  kavi open [--goal \"...\"]",
         "  kavi resume",
+        "  kavi summary [--json]",
+        "  kavi result [--json]",
         "  kavi status [--json]",
+        "  kavi activity [--json] [--limit N]",
         "  kavi route [--json] [--no-ai] <prompt>",
         "  kavi routes [--json] [--limit N]",
         "  kavi paths [--json]",
         "  kavi task [--agent codex|claude|auto] <prompt>",
-        "  kavi recommend [--json]",
-        "  kavi recommend-apply <recommendation-id>",
+        "  kavi recommend [--json] [--all] [--kind handoff|integration|ownership-config] [--status active|dismissed] [--agent codex|claude|operator]",
+        "  kavi recommend-apply <recommendation-id> [--force]",
+        "  kavi recommend-dismiss <recommendation-id> [--reason \"...\"]",
+        "  kavi recommend-restore <recommendation-id>",
         "  kavi tasks [--json]",
         "  kavi task-output <task-id|latest> [--json]",
         "  kavi decisions [--json] [--limit N]",
@@ -425,6 +450,29 @@ async function tryRpcSnapshot(paths) {
     }
     return await readSnapshot(paths);
 }
+async function loadSnapshot(paths, eventLimit = 80) {
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    if (rpcSnapshot) {
+        return rpcSnapshot;
+    }
+    const session = await loadSessionRecord(paths);
+    const approvals = await listApprovalRequests(paths, {
+        includeResolved: true
+    });
+    const events = await readRecentEvents(paths, eventLimit);
+    const worktreeDiffs = await Promise.all(session.worktrees.map(async (worktree)=>({
+            agent: worktree.agent,
+            paths: await listWorktreeChangedPaths(worktree.path, session.baseCommit)
+        })));
+    const latestLandReport = await loadLatestLandReport(paths);
+    return {
+        session,
+        approvals,
+        events,
+        worktreeDiffs,
+        latestLandReport
+    };
+}
 async function notifyOperatorSurface(paths, reason) {
     if (!await pingRpc(paths)) {
         return;
@@ -480,14 +528,17 @@ async function commandStart(cwd, args) {
 }
 async function commandStatus(cwd, args) {
     const { paths } = await requireSession(cwd);
-    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 snapshot = await loadSnapshot(paths, 60);
+    const session = snapshot.session;
+    const pendingApprovals = snapshot.approvals.filter((item)=>item.status === "pending");
     const heartbeatAgeMs = sessionHeartbeatAgeMs(session);
     const routeAnalytics = buildRouteAnalytics(session.tasks);
     const ownershipConflicts = findOwnershipRuleConflicts(session.config);
     const claimHotspots = buildClaimHotspots(session);
-    const recommendations = buildOperatorRecommendations(session);
+    const recommendations = buildOperatorRecommendations(session, {
+        includeDismissed: true
+    });
+    const workflowSummary = buildWorkflowSummary(snapshot);
     const payload = {
         id: session.id,
         status: session.status,
@@ -497,8 +548,14 @@ async function commandStatus(cwd, args) {
         daemonPid: session.daemonPid,
         daemonHeartbeatAt: session.daemonHeartbeatAt,
         daemonHealthy: isSessionLive(session),
-        rpcConnected: rpcSnapshot !== null,
+        rpcConnected: await pingRpc(paths),
         heartbeatAgeMs,
+        workflowStage: workflowSummary.stage,
+        latestLandReport: workflowSummary.latestLandReport ? {
+            id: workflowSummary.latestLandReport.id,
+            createdAt: workflowSummary.latestLandReport.createdAt,
+            targetBranch: workflowSummary.latestLandReport.targetBranch
+        } : null,
         runtime: session.runtime,
         taskCounts: {
             total: session.tasks.length,
@@ -523,6 +580,9 @@ async function commandStatus(cwd, args) {
         },
         recommendationCounts: {
             total: recommendations.length,
+            active: recommendations.filter((item)=>item.status === "active").length,
+            dismissed: recommendations.filter((item)=>item.status === "dismissed").length,
+            withOpenFollowUps: recommendations.filter((item)=>item.openFollowUpTaskIds.length > 0).length,
             integration: recommendations.filter((item)=>item.kind === "integration").length,
             handoff: recommendations.filter((item)=>item.kind === "handoff").length,
             ownershipConfig: recommendations.filter((item)=>item.kind === "ownership-config").length
@@ -545,6 +605,10 @@ async function commandStatus(cwd, args) {
     console.log(`Repo: ${payload.repoRoot}`);
     console.log(`Control: ${payload.socketPath}${payload.rpcConnected ? " (connected)" : " (disconnected)"}`);
     console.log(`Goal: ${payload.goal ?? "-"}`);
+    console.log(`Workflow stage: ${payload.workflowStage.label} | ${payload.workflowStage.detail}`);
+    if (payload.latestLandReport) {
+        console.log(`Latest land: ${payload.latestLandReport.createdAt} -> ${payload.latestLandReport.targetBranch}`);
+    }
     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}`);
@@ -553,7 +617,7 @@ async function commandStatus(cwd, args) {
     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}`);
-    console.log(`Recommendations: total=${payload.recommendationCounts.total} integration=${payload.recommendationCounts.integration} handoff=${payload.recommendationCounts.handoff} ownership-config=${payload.recommendationCounts.ownershipConfig}`);
+    console.log(`Recommendations: total=${payload.recommendationCounts.total} active=${payload.recommendationCounts.active} dismissed=${payload.recommendationCounts.dismissed} open-followups=${payload.recommendationCounts.withOpenFollowUps} integration=${payload.recommendationCounts.integration} handoff=${payload.recommendationCounts.handoff} ownership-config=${payload.recommendationCounts.ownershipConfig}`);
     console.log(`Routes: codex=${payload.routeCounts.byOwner.codex} claude=${payload.routeCounts.byOwner.claude} | strategies=${Object.entries(payload.routeCounts.byStrategy).map(([strategy, count])=>`${strategy}:${count}`).join(", ") || "-"}`);
     console.log(`Ownership conflicts: ${payload.ownershipConflicts} | Claim hotspots: ${payload.claimHotspots}`);
     console.log(`Routing ownership: codex=${payload.routingOwnership.codexPaths.join(", ") || "-"} | claude=${payload.routingOwnership.claudePaths.join(", ") || "-"}`);
@@ -561,6 +625,128 @@ async function commandStatus(cwd, args) {
         console.log(`- ${worktree.agent}: ${worktree.path}`);
     }
 }
+async function commandSummary(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const snapshot = await loadSnapshot(paths, 120);
+    const artifacts = await listTaskArtifacts(paths);
+    const summary = buildWorkflowSummary(snapshot, artifacts);
+    const result = buildWorkflowResult(snapshot, artifacts);
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(summary, null, 2));
+        return;
+    }
+    console.log(`Goal: ${summary.goal ?? "-"}`);
+    console.log(`Stage: ${summary.stage.label} | ${summary.stage.detail}`);
+    console.log(`Headline: ${result.headline}`);
+    console.log(`Tasks: pending=${summary.taskCounts.pending} running=${summary.taskCounts.running} blocked=${summary.taskCounts.blocked} completed=${summary.taskCounts.completed} failed=${summary.taskCounts.failed}`);
+    console.log(`Approvals: pending=${summary.approvalCounts.pending} | Reviews: open=${summary.reviewCounts.open} | Recommendations: active=${summary.recommendationCounts.active} dismissed=${summary.recommendationCounts.dismissed}`);
+    console.log(`Land readiness: ${summary.landReadiness.state}`);
+    if (summary.latestLandReport) {
+        console.log(`Latest landed result: ${summary.latestLandReport.createdAt} -> ${summary.latestLandReport.targetBranch}`);
+    }
+    if (summary.landReadiness.blockers.length > 0) {
+        console.log("Blockers:");
+        for (const blocker of summary.landReadiness.blockers){
+            console.log(`- ${blocker}`);
+        }
+    }
+    if (summary.landReadiness.warnings.length > 0) {
+        console.log("Warnings:");
+        for (const warning of summary.landReadiness.warnings){
+            console.log(`- ${warning}`);
+        }
+    }
+    console.log("Current changes:");
+    for (const changeSet of summary.changedByAgent){
+        console.log(`- ${changeSet.agent}: ${changeSet.paths.length} path(s)${changeSet.paths.length > 0 ? ` | ${changeSet.paths.join(", ")}` : ""}`);
+    }
+    if (summary.completedTasks.length > 0) {
+        console.log("Completed results:");
+        for (const task of summary.completedTasks.slice(0, 8)){
+            console.log(`- ${task.taskId} | ${task.owner} | ${task.title} | ${task.summary}${task.claimedPaths.length > 0 ? ` | paths=${task.claimedPaths.join(", ")}` : ""}`);
+        }
+    }
+    if (summary.recentActivity.length > 0) {
+        console.log("Recent activity:");
+        for (const entry of summary.recentActivity.slice(0, 8)){
+            console.log(`- ${entry.timestamp} | ${entry.title} | ${entry.detail}`);
+        }
+    }
+    if (summary.landReadiness.nextActions.length > 0) {
+        console.log("Next actions:");
+        for (const action of summary.landReadiness.nextActions){
+            console.log(`- ${action}`);
+        }
+    }
+}
+async function commandResult(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const snapshot = await loadSnapshot(paths, 120);
+    const artifacts = await listTaskArtifacts(paths);
+    const result = buildWorkflowResult(snapshot, artifacts);
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`Goal: ${result.goal ?? "-"}`);
+    console.log(`Stage: ${result.stage.label} | ${result.stage.detail}`);
+    console.log(`Headline: ${result.headline}`);
+    if (result.latestLandReport) {
+        console.log(`Latest land: ${result.latestLandReport.createdAt} | ${result.latestLandReport.targetBranch}`);
+        console.log(`Validation: ${result.latestLandReport.validationCommand.trim() || "(none configured)"} | ${result.latestLandReport.validationStatus} | ${result.latestLandReport.validationDetail}`);
+        console.log(`Review threads landed: ${result.latestLandReport.reviewThreadsLanded}`);
+    } else {
+        console.log("Latest land: none yet");
+    }
+    console.log("Agent results:");
+    for (const agent of result.agentResults){
+        console.log(`- ${agent.agent}: completed=${agent.completedTaskCount} | latest=${agent.latestTaskTitle ?? "-"} | ${agent.latestSummary ?? "No completed result yet."}`);
+        if (agent.changedPaths.length > 0) {
+            console.log(`  unlanded: ${agent.changedPaths.join(", ")}`);
+        } else if (agent.landedPaths.length > 0) {
+            console.log(`  landed: ${agent.landedPaths.join(", ")}`);
+        }
+    }
+    if (result.completedTasks.length > 0) {
+        console.log("Completed outputs:");
+        for (const task of result.completedTasks.slice(0, 8)){
+            console.log(`- ${task.owner} | ${task.title} | ${task.summary}${task.claimedPaths.length > 0 ? ` | paths=${task.claimedPaths.join(", ")}` : ""}`);
+        }
+    }
+    if (result.latestLandReport?.summary.length) {
+        console.log("Merged result summary:");
+        for (const line of result.latestLandReport.summary){
+            console.log(`- ${line}`);
+        }
+    } else {
+        console.log("Result summary:");
+        for (const line of result.summaryLines.slice(0, 6)){
+            console.log(`- ${line}`);
+        }
+    }
+    if (result.nextActions.length > 0) {
+        console.log("Next actions:");
+        for (const action of result.nextActions){
+            console.log(`- ${action}`);
+        }
+    }
+}
+async function commandActivity(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const limitArg = getFlag(args, "--limit");
+    const limit = limitArg ? Number(limitArg) : 30;
+    const snapshot = await loadSnapshot(paths, Math.max(50, Number.isFinite(limit) ? limit : 30));
+    const artifacts = await listTaskArtifacts(paths);
+    const activity = buildWorkflowActivity(snapshot, artifacts, Math.max(1, Number.isFinite(limit) ? limit : 30));
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(activity, null, 2));
+        return;
+    }
+    for (const entry of activity){
+        console.log(`${entry.timestamp} ${entry.title}`);
+        console.log(`  ${entry.detail}`);
+    }
+}
 async function commandRoute(cwd, args) {
     const prompt = getGoal(args);
     if (!prompt) {
@@ -645,7 +831,18 @@ async function commandRecommend(cwd, args) {
     const { paths } = await requireSession(cwd);
     const rpcSnapshot = await tryRpcSnapshot(paths);
     const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
-    const recommendations = buildOperatorRecommendations(session);
+    const kind = parseRecommendationKind(getOptionalFilter(args, "--kind"));
+    const status = parseRecommendationStatus(getOptionalFilter(args, "--status"));
+    const targetAgent = getOptionalFilter(args, "--agent");
+    if (targetAgent && targetAgent !== "codex" && targetAgent !== "claude" && targetAgent !== "operator" && targetAgent !== "all") {
+        throw new Error(`Unsupported recommendation agent "${targetAgent}".`);
+    }
+    const recommendations = buildOperatorRecommendations(session, {
+        includeDismissed: args.includes("--all") || status === "dismissed" || status === "all",
+        kind: kind ?? undefined,
+        status: status ?? undefined,
+        targetAgent: targetAgent ?? undefined
+    });
     if (args.includes("--json")) {
         console.log(JSON.stringify(recommendations, null, 2));
         return;
@@ -655,9 +852,13 @@ async function commandRecommend(cwd, args) {
         return;
     }
     for (const recommendation of recommendations){
-        console.log(`${recommendation.id} | ${recommendation.kind} | ${recommendation.targetAgent ?? "-"}`);
+        console.log(`${recommendation.id} | ${recommendation.status} | ${recommendation.kind} | ${recommendation.targetAgent ?? "-"}`);
         console.log(`  title: ${recommendation.title}`);
         console.log(`  detail: ${recommendation.detail}`);
+        console.log(`  open follow-ups: ${recommendation.openFollowUpTaskIds.join(", ") || "-"}`);
+        if (recommendation.dismissedReason) {
+            console.log(`  dismissed reason: ${recommendation.dismissedReason}`);
+        }
         console.log(`  command: ${recommendation.commandHint}`);
     }
 }
@@ -669,65 +870,82 @@ async function commandRecommendApply(cwd, args) {
     if (!recommendationId) {
         throw new Error("A recommendation id is required. Example: kavi recommend-apply integration:src/ui/App.tsx");
     }
-    const recommendation = buildOperatorRecommendations(session).find((item)=>item.id === recommendationId);
-    if (!recommendation) {
-        throw new Error(`Recommendation ${recommendationId} was not found.`);
-    }
-    if (recommendation.kind === "ownership-config") {
-        throw new Error(`Recommendation ${recommendation.id} is advisory only. Run "${recommendation.commandHint}" and update the config manually.`);
-    }
-    const owner = recommendation.targetAgent === "operator" || recommendation.targetAgent === null ? "codex" : recommendation.targetAgent;
-    const prompt = recommendation.kind === "integration" ? [
-        "Coordinate and resolve overlapping agent work before landing.",
-        recommendation.detail,
-        recommendation.filePath ? `Primary hotspot: ${recommendation.filePath}` : null
-    ].filter(Boolean).join("\n") : [
-        "Pick up ownership-aware handoff work from Kavi.",
-        recommendation.detail,
-        recommendation.filePath ? `Focus path: ${recommendation.filePath}` : null
-    ].filter(Boolean).join("\n");
-    const routeDecision = {
-        owner,
-        strategy: "manual",
-        confidence: 1,
-        reason: `Queued from Kavi recommendation ${recommendation.id}.`,
-        claimedPaths: recommendation.filePath ? [
-            recommendation.filePath
-        ] : [],
-        metadata: {
-            recommendationId: recommendation.id,
-            recommendationKind: recommendation.kind
-        }
-    };
+    const plan = buildRecommendationActionPlan(session, recommendationId, {
+        force: args.includes("--force")
+    });
     if (rpcSnapshot) {
         await rpcEnqueueTask(paths, {
-            owner: routeDecision.owner,
-            prompt,
-            routeReason: routeDecision.reason,
-            routeMetadata: routeDecision.metadata,
-            claimedPaths: routeDecision.claimedPaths,
-            routeStrategy: routeDecision.strategy,
-            routeConfidence: routeDecision.confidence
+            owner: plan.owner,
+            prompt: plan.prompt,
+            routeReason: plan.routeReason,
+            routeMetadata: plan.routeMetadata,
+            claimedPaths: plan.claimedPaths,
+            routeStrategy: plan.routeStrategy,
+            routeConfidence: plan.routeConfidence,
+            recommendationId: plan.recommendation.id,
+            recommendationKind: plan.recommendation.kind
         });
     } else {
         await appendCommand(paths, "enqueue", {
-            owner: routeDecision.owner,
-            prompt,
-            routeReason: routeDecision.reason,
-            routeMetadata: routeDecision.metadata,
-            claimedPaths: routeDecision.claimedPaths,
-            routeStrategy: routeDecision.strategy,
-            routeConfidence: routeDecision.confidence
+            owner: plan.owner,
+            prompt: plan.prompt,
+            routeReason: plan.routeReason,
+            routeMetadata: plan.routeMetadata,
+            claimedPaths: plan.claimedPaths,
+            routeStrategy: plan.routeStrategy,
+            routeConfidence: plan.routeConfidence,
+            recommendationId: plan.recommendation.id,
+            recommendationKind: plan.recommendation.kind
         });
     }
-    await recordEvent(paths, session.id, "recommendation.applied", {
-        recommendationId: recommendation.id,
-        recommendationKind: recommendation.kind,
-        owner,
-        filePath: recommendation.filePath
-    });
-    await notifyOperatorSurface(paths, "recommendation.applied");
-    console.log(`Queued ${owner} task from recommendation ${recommendation.id}.`);
+    console.log(`Queued ${plan.owner} task from recommendation ${plan.recommendation.id}.`);
+}
+async function commandRecommendDismiss(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const recommendationId = args.find((arg)=>!arg.startsWith("--"));
+    if (!recommendationId) {
+        throw new Error("A recommendation id is required. Example: kavi recommend-dismiss integration:src/ui");
+    }
+    const reason = getOptionalFilter(args, "--reason");
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
+    const recommendation = dismissOperatorRecommendation(session, recommendationId, reason);
+    if (rpcSnapshot) {
+        await rpcDismissRecommendation(paths, {
+            recommendationId,
+            reason
+        });
+    } else {
+        await saveSessionRecord(paths, session);
+        await recordEvent(paths, session.id, "recommendation.dismissed", {
+            recommendationId,
+            reason
+        });
+        await notifyOperatorSurface(paths, "recommendation.dismissed");
+    }
+    console.log(`Dismissed recommendation ${recommendation.id}.`);
+}
+async function commandRecommendRestore(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const recommendationId = args.find((arg)=>!arg.startsWith("--"));
+    if (!recommendationId) {
+        throw new Error("A recommendation id is required. Example: kavi recommend-restore integration:src/ui");
+    }
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
+    const recommendation = restoreOperatorRecommendation(session, recommendationId);
+    if (rpcSnapshot) {
+        await rpcRestoreRecommendation(paths, {
+            recommendationId
+        });
+    } else {
+        await saveSessionRecord(paths, session);
+        await recordEvent(paths, session.id, "recommendation.restored", {
+            recommendationId
+        });
+        await notifyOperatorSurface(paths, "recommendation.restored");
+    }
+    console.log(`Restored recommendation ${recommendation.id}.`);
 }
 async function commandPaths(cwd, args) {
     const repoRoot = await findRepoRoot(cwd) ?? cwd;
@@ -743,6 +961,7 @@ async function commandPaths(cwd, args) {
         integrationRoot: paths.integrationRoot,
         stateFile: paths.stateFile,
         eventsFile: paths.eventsFile,
+        reportsDir: paths.reportsDir,
         approvalsFile: paths.approvalsFile,
         commandsFile: paths.commandsFile,
         socketPath: paths.socketPath,
@@ -764,6 +983,7 @@ async function commandPaths(cwd, args) {
     console.log(`Integration: ${payload.integrationRoot}`);
     console.log(`State file: ${payload.stateFile}`);
     console.log(`Events file: ${payload.eventsFile}`);
+    console.log(`Reports: ${payload.reportsDir}`);
     console.log(`Approvals file: ${payload.approvalsFile}`);
     console.log(`Command queue: ${payload.commandsFile}`);
     console.log(`Control socket: ${payload.socketPath}`);
@@ -1113,6 +1333,10 @@ async function commandLand(cwd) {
     const paths = resolveAppPaths(repoRoot);
     const session = await loadSessionRecord(paths);
     const targetBranch = await resolveTargetBranch(repoRoot, session.config.baseBranch);
+    const preLandChanges = await Promise.all(session.worktrees.map(async (worktree)=>({
+            agent: worktree.agent,
+            paths: await listWorktreeChangedPaths(worktree.path, session.baseCommit)
+        })));
     const overlappingPaths = await findOverlappingWorktreePaths(session.worktrees, session.baseCommit);
     if (overlappingPaths.length > 0) {
         const existing = session.tasks.find((task)=>task.status === "pending" && task.title === "Resolve integration overlap");
@@ -1158,6 +1382,10 @@ async function commandLand(cwd) {
             overlappingPaths
         });
         console.log("Landing blocked because both agent worktrees changed overlapping paths.");
+        console.log("Current change surface:");
+        for (const changeSet of preLandChanges){
+            console.log(`- ${changeSet.agent}: ${changeSet.paths.length} path(s)${changeSet.paths.length > 0 ? ` | ${changeSet.paths.join(", ")}` : ""}`);
+        }
         console.log("Queued integration task for codex:");
         for (const filePath of overlappingPaths){
             console.log(`- ${filePath}`);
@@ -1175,6 +1403,7 @@ async function commandLand(cwd) {
     const releasedClaims = releasePathClaims(session, {
         note: `Released after landing into ${targetBranch}.`
     });
+    session.baseCommit = await getBranchCommit(repoRoot, targetBranch);
     for (const claim of releasedClaims){
         addDecisionRecord(session, {
             kind: "integration",
@@ -1236,10 +1465,40 @@ async function commandLand(cwd) {
         artifact.reviewNotes = session.reviewNotes.filter((note)=>note.taskId === taskId);
         await saveTaskArtifact(paths, artifact);
     }
+    const artifacts = await listTaskArtifacts(paths);
+    const postLandSnapshot = await loadSnapshot(paths, 60);
+    const postLandSummary = buildWorkflowSummary(postLandSnapshot, artifacts);
+    const landReport = buildLandReport({
+        id: buildSessionId(),
+        sessionId: session.id,
+        goal: session.goal,
+        createdAt: new Date().toISOString(),
+        targetBranch,
+        integrationBranch: result.integrationBranch,
+        integrationPath: result.integrationPath,
+        validationCommand: session.config.validationCommand,
+        validationStatus: result.validation.status,
+        validationDetail: result.validation.detail,
+        changedByAgent: preLandChanges,
+        completedTasks: postLandSummary.completedTasks,
+        snapshotCommits: result.snapshotCommits,
+        commandsRun: result.commandsRun,
+        reviewThreadsLanded: landedReviewNotes.length,
+        openReviewThreadsRemaining: session.reviewNotes.filter((note)=>note.status === "open").length
+    });
+    await saveLandReport(paths, landReport);
     await notifyOperatorSurface(paths, "land.completed");
     console.log(`Landed branches into ${targetBranch}`);
     console.log(`Integration branch: ${result.integrationBranch}`);
     console.log(`Integration worktree: ${result.integrationPath}`);
+    console.log("Merged change surface:");
+    for (const changeSet of preLandChanges){
+        console.log(`- ${changeSet.agent}: ${changeSet.paths.length} path(s)${changeSet.paths.length > 0 ? ` | ${changeSet.paths.join(", ")}` : ""}`);
+    }
+    console.log(`Validation: ${result.validation.command || "(none configured)"} | ${result.validation.status} | ${result.validation.detail}`);
+    console.log(`Review threads landed: ${landedReviewNotes.length}`);
+    console.log(`Result report: ${landReport.id}`);
+    console.log("Inspect result: kavi result");
     for (const snapshot of result.snapshotCommits){
         console.log(`Snapshot ${snapshot.agent}: ${snapshot.commit}${snapshot.createdCommit ? " (created)" : " (unchanged)"}`);
     }
@@ -1386,9 +1645,18 @@ async function main() {
         case "resume":
             await commandResume(cwd);
             break;
+        case "summary":
+            await commandSummary(cwd, args);
+            break;
+        case "result":
+            await commandResult(cwd, args);
+            break;
         case "status":
             await commandStatus(cwd, args);
             break;
+        case "activity":
+            await commandActivity(cwd, args);
+            break;
         case "route":
             await commandRoute(cwd, args);
             break;
@@ -1407,6 +1675,12 @@ async function main() {
         case "recommend-apply":
             await commandRecommendApply(cwd, args);
             break;
+        case "recommend-dismiss":
+            await commandRecommendDismiss(cwd, args);
+            break;
+        case "recommend-restore":
+            await commandRecommendRestore(cwd, args);
+            break;
         case "tasks":
             await commandTasks(cwd, args);
             break;

package/dist/paths.js

@@ -9,6 +9,7 @@ export function resolveAppPaths(repoRoot) {
     const homeStateDir = process.env.KAVI_HOME_STATE_DIR ?? path.join(home, ".local", "state", "kavi");
     const runtimeDir = path.join(kaviDir, "runtime");
     const stateDir = path.join(kaviDir, "state");
+    const reportsDir = path.join(stateDir, "reports");
     const runsDir = path.join(runtimeDir, "runs");
     return {
         repoRoot,
@@ -16,6 +17,7 @@ export function resolveAppPaths(repoRoot) {
         configFile: path.join(kaviDir, "config.toml"),
         promptsDir: path.join(kaviDir, "prompts"),
         stateDir,
+        reportsDir,
         runtimeDir,
         runsDir,
         stateFile: path.join(stateDir, "session.json"),