@mandipadk7/kavi 0.1.7 → 1.0.1

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, rpcSetFullAccessMode, 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",
@@ -31,6 +33,9 @@ const CLAUDE_AUTO_ALLOW_TOOLS = new Set([
     "Grep",
     "LS"
 ]);
+function hasFlag(args, name) {
+    return args.includes(name);
+}
 function getFlag(args, name) {
     const index = args.indexOf(name);
     if (index === -1) {
@@ -58,6 +63,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 "";
@@ -92,16 +115,21 @@ function renderUsage() {
         "  kavi init [--home] [--no-commit]",
         "  kavi doctor [--json]",
         "  kavi update [--check] [--dry-run] [--yes] [--tag latest|beta] [--version X.Y.Z]",
-        "  kavi start [--goal \"...\"]",
-        "  kavi open [--goal \"...\"]",
+        "  kavi start [--goal \"...\"] [--approve-all]",
+        "  kavi open [--goal \"...\"] [--approve-all]",
         "  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]",
@@ -335,7 +363,10 @@ async function commandUpdate(cwd, args) {
     }
     console.log(`Updated ${packageInfo.name} from ${packageInfo.version} to ${targetVersion}.`);
 }
-async function startOrAttachSession(cwd, goal) {
+function renderFullAccessWarning() {
+    return "WARNING: approve-all is enabled. Claude and Codex will run with full access, and Kavi approval prompts will be bypassed for future turns.";
+}
+async function startOrAttachSession(cwd, goal, enableFullAccessMode) {
     const prepared = await prepareProjectContext(cwd, {
         createRepository: true,
         ensureHeadCommit: false,
@@ -346,6 +377,11 @@ async function startOrAttachSession(cwd, goal) {
         try {
             const session = await loadSessionRecord(paths);
             if (isSessionLive(session) && await pingRpc(paths)) {
+                if (enableFullAccessMode && !session.fullAccessMode) {
+                    await rpcSetFullAccessMode(paths, {
+                        enabled: true
+                    });
+                }
                 if (goal) {
                     await rpcKickoff(paths, goal);
                 }
@@ -366,7 +402,7 @@ async function startOrAttachSession(cwd, goal) {
     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);
+    await createSessionRecord(paths, config, runtime, sessionId, baseCommit, worktrees, goal, rpcEndpoint, enableFullAccessMode);
     if (prepared.createdRepository) {
         await recordEvent(paths, sessionId, "repo.initialized", {
             repoRoot
@@ -425,6 +461,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;
@@ -454,9 +513,13 @@ function buildRouteAnalytics(tasks) {
 }
 async function commandOpen(cwd, args) {
     const goal = getGoal(args);
-    await startOrAttachSession(cwd, goal);
+    await startOrAttachSession(cwd, goal, hasFlag(args, "--approve-all"));
     const repoRoot = await detectRepoRoot(cwd);
     const paths = resolveAppPaths(repoRoot);
+    const session = await loadSessionRecord(paths);
+    if (session.fullAccessMode) {
+        console.log(renderFullAccessWarning());
+    }
     await attachTui(paths);
 }
 async function commandResume(cwd) {
@@ -466,28 +529,35 @@ async function commandResume(cwd) {
 }
 async function commandStart(cwd, args) {
     const goal = getGoal(args);
-    const socketPath = await startOrAttachSession(cwd, goal);
+    const socketPath = await startOrAttachSession(cwd, goal, hasFlag(args, "--approve-all"));
     const repoRoot = await detectRepoRoot(cwd);
     const paths = resolveAppPaths(repoRoot);
     const session = await loadSessionRecord(paths);
     console.log(`Started Kavi session ${session.id}`);
     console.log(`Repo: ${repoRoot}`);
     console.log(`Control: ${socketPath}`);
+    console.log(`Access: ${session.fullAccessMode ? "approve-all" : "standard"}`);
     console.log(`Runtime: node=${session.runtime.nodeExecutable} codex=${session.runtime.codexExecutable} claude=${session.runtime.claudeExecutable}`);
+    if (session.fullAccessMode) {
+        console.log(renderFullAccessWarning());
+    }
     for (const worktree of session.worktrees){
         console.log(`- ${worktree.agent}: ${worktree.path}`);
     }
 }
 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,
@@ -496,9 +566,16 @@ async function commandStatus(cwd, args) {
         goal: session.goal,
         daemonPid: session.daemonPid,
         daemonHeartbeatAt: session.daemonHeartbeatAt,
+        fullAccessMode: session.fullAccessMode,
         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 +600,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
@@ -544,7 +624,12 @@ async function commandStatus(cwd, args) {
     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(`Access: ${payload.fullAccessMode ? "approve-all" : "standard"}`);
     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 +638,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 +646,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 +852,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 +873,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 +891,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 +982,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 +1004,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 +1354,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 +1403,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 +1424,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 +1486,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)"}`);
     }
@@ -1269,6 +1549,18 @@ async function commandHook(args) {
     };
     if (session && agent === "claude" && eventName === "PreToolUse") {
         const descriptor = describeToolUse(payload);
+        if (session.fullAccessMode) {
+            console.log(JSON.stringify({
+                continue: true,
+                suppressOutput: true,
+                hookSpecificOutput: {
+                    hookEventName: "PreToolUse",
+                    permissionDecision: "allow",
+                    permissionDecisionReason: `Kavi approve-all bypassed approval: ${descriptor.summary}`
+                }
+            }));
+            return;
+        }
         if (CLAUDE_AUTO_ALLOW_TOOLS.has(descriptor.toolName)) {
             await recordEvent(paths, session.id, "approval.auto_allowed", {
                 agent,
@@ -1386,9 +1678,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 +1708,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;