@mandipadk7/kavi 0.1.7 → 1.0.1

package/README.md

@@ -9,16 +9,20 @@ Current capabilities:
 - `kavi init --no-commit`: skip the bootstrap commit and let `kavi open` or `kavi start` create the first base commit later.
 - `kavi doctor`: verify Node, Codex, Claude, git worktree support, and local readiness.
 - `kavi update`: check for and install a newer published Kavi package from npm.
-- `kavi start`: start a managed session without attaching the TUI.
-- `kavi open`: create a managed session with separate Codex and Claude worktrees and open the full-screen operator console, even from an empty folder or a repo with no `HEAD` yet.
+- `kavi start`: start a managed session without attaching the TUI. Add `--approve-all` to run future Codex and Claude turns with full access and without Kavi approval prompts.
+- `kavi open`: create a managed session with separate Codex and Claude worktrees and open the full-screen operator console, even from an empty folder or a repo with no `HEAD` yet. Add `--approve-all` to start in full-access mode.
 - `kavi resume`: reopen the operator console for the current repo session.
+- `kavi summary`: show a cohesive session-level view of progress, current changes, recent activity, and landing readiness.
+- `kavi result`: show the current or latest landed outcome as one cohesive result surface, including per-agent output and merged landing details.
 - `kavi status`: inspect session health, task counts, and configured routing ownership rules from any terminal.
+- `kavi activity`: show the session as a linear activity stream instead of raw daemon events.
 - `kavi route`: preview how Kavi would route a prompt before enqueuing it.
 - `kavi routes`: inspect recent task routing decisions with strategy, confidence, and metadata.
 - `kavi paths`: inspect resolved repo-local, user-local, worktree, and runtime paths.
 - `kavi task`: enqueue a task for `codex`, `claude`, or `auto` routing.
-- `kavi recommend`: inspect integration, handoff, and ownership-configuration recommendations derived from live claims, reviews, and routing state.
+- `kavi recommend`: inspect integration, handoff, and ownership-configuration recommendations derived from live claims, reviews, and routing state, with filters for kind, target agent, and active vs dismissed status.
 - `kavi recommend-apply`: turn an actionable handoff or integration recommendation into a queued managed task.
+- `kavi recommend-dismiss` and `kavi recommend-restore`: manage the recommendation inbox without losing the underlying session context.
 - `kavi tasks`: inspect the session task list with summaries and artifact availability.
 - `kavi task-output`: inspect the normalized envelope and raw output for a completed task.
 - `kavi decisions`: inspect the persisted routing, approval, task, and integration decisions.
@@ -37,8 +41,10 @@ Runtime model:
 - User-local runtime overrides live in `~/.config/kavi/config.toml` and can point Kavi at custom `node`, `codex`, and `claude` binaries.
 - The operator surface talks to the daemon over a local control socket under the machine-local state root.
 - SQLite event mirroring is opt-in with `KAVI_ENABLE_SQLITE_HISTORY=1`; the default event log is JSONL under `.kavi/state/events.jsonl`.
-- The operator console exposes a task board, dual agent lanes, a live inspector pane, approval actions, inline task composition, worktree diff review with file and hunk navigation, and persisted operator review threads on files or hunks.
+- Landed result reports are persisted under `.kavi/state/reports/`, so the latest merged outcome remains inspectable after the landing command exits.
+- The operator console now opens on an activity-first view so the session reads like a linear progress log, while still exposing dedicated results, task board, dual agent lanes, approvals, diff review, and persisted operator review threads when you need to drill in.
 - Routing can now use explicit path ownership rules from `.kavi/config.toml` via `[routing].codex_paths` and `[routing].claude_paths`, so known parts of the tree can bypass looser keyword or AI routing.
+- Validation is optional by default for new repos. Set `validation_command` in `.kavi/config.toml` once the project has a real test or build command you want Kavi to enforce during `land`.
 - Ownership routing now prefers the strongest matching rule, not just the side with the most raw glob hits, and route metadata records the winning rule when one exists.
 - Diff-based path claims now release older overlapping same-agent claims automatically, so the active claim set stays closer to each managed worktree's current unlanded surface.
 
@@ -46,27 +52,35 @@ Notes:
 - `kavi init` and `kavi open` now support the "empty folder to first managed session" path. If no git repo exists, Kavi initializes one; if git exists but no `HEAD` exists yet, Kavi creates the bootstrap commit it needs for worktrees.
 - Codex runs through `codex app-server` in managed mode, so Codex-side approvals now land in the same Kavi inbox as Claude hook approvals.
 - Claude still runs through the installed `claude` CLI with Kavi-managed hooks and approval decisions.
+- `--approve-all` and the operator console's `!` toggle switch Kavi into a full-access mode for future turns. In that mode, Claude runs with `--dangerously-skip-permissions`, Codex runs with its no-approval danger-full-access equivalent, and Kavi stops prompting for approvals on those future turns.
 - `kavi doctor` now checks Claude auth readiness with `claude auth status`, and startup blocks if Claude is installed but not authenticated.
 - `kavi doctor` also validates ownership path rules for duplicates, repo escapes, and absolute-path mistakes before those rules affect routing.
 - `kavi doctor` now also flags overlapping cross-agent ownership rules that do not produce a clear specificity winner.
 - The dashboard and operator commands now use the daemon's local RPC socket instead of editing session files directly, and the TUI stays updated from pushed daemon snapshots rather than polling.
 - The socket is machine-local rather than repo-local to avoid Unix socket path-length issues in deep repos and temp directories.
-- The console is keyboard-driven: `1-7` switch views, `j/k` move selection, `[` and `]` cycle task detail sections, `,` and `.` cycle changed files, `{` and `}` cycle patch hunks, `A/C/Q/M` add review notes, `o/O` cycle existing threads, `T` reply, `E` edit, `R` resolve or reopen, `a` cycle thread assignee, `w` mark a thread as won't-fix, `x` mark it as accepted-risk, `F` queue a fix task, `H` queue a handoff task, `y/n` resolve approvals, and `c` opens the inline task composer with live route preview diagnostics.
+- The console is keyboard-driven: `1-9` switch views, `j/k` move selection, `[` and `]` cycle task detail sections, `,` and `.` cycle changed files, `{` and `}` cycle patch hunks, `A/C/Q/M` add review notes, `o/O` cycle existing threads, `T` reply, `E` edit, `R` resolve or reopen, `a` cycle thread assignee, `w` mark a thread as won't-fix, `x` mark it as accepted-risk, `F` queue a fix task, `H` queue a handoff task, `y/n` resolve approvals, `!` toggles full-access mode, and `c` opens the inline task composer with live route preview diagnostics. Inside the composer, digits are treated as literal text and `Tab` cycles the route owner.
 - Review filters are available both in the CLI and the TUI: `kavi reviews --assignee operator --status open`, and inside the console use `u`, `v`, and `d` to cycle assignee, status, and disposition filters for the active diff context.
 - The claims inspector now shows active overlap hotspots and ownership-rule conflicts so routing pressure points are visible directly in the operator surface.
 - The claims and decision inspectors now also show recommendation-driven next actions, so hotspots, cross-agent review pressure, and ownership-config problems can be turned into follow-up tasks directly from the operator surface.
+- Recommendations now have a persisted lifecycle of their own: they can be dismissed, restored, and tracked across follow-up tasks, and repeated applies are guarded when an open follow-up task already exists.
 - Review threads now carry explicit assignees and richer dispositions, including `accepted risk` and `won't fix`, instead of relying only on free-form note text.
 - Successful follow-up tasks now auto-resolve linked open review threads, landed follow-up work marks those resolved threads as landed, and replying to a resolved thread reopens it.
 - `kavi update --check` reports newer published builds without installing them, and `kavi update` can apply a chosen `latest`, `beta`, or exact version after confirmation.
+- The operator console now includes a dedicated recommendations view. Use `4` to switch there, `Enter` to apply a recommendation, `P` to force an additional follow-up task when one is already open, `z` to dismiss, and `Z` to restore.
+- `kavi land` now prints a clearer merged-result summary, including the pre-land change surface by agent, validation status, and how many review threads were landed as part of the merge.
+- After `kavi land`, run `kavi result` to inspect the persisted merged-result report and the latest per-agent outcome in one place.
 
-Install commands for testers:
+Install commands:
 
 ```bash
+# stable
+npm install -g @mandipadk7/kavi
+
 # beta channel
 npm install -g @mandipadk7/kavi@beta
 
 # one-off
-npx @mandipadk7/kavi@beta help
+npx @mandipadk7/kavi help
 ```
 
 User-local config example:

package/dist/adapters/claude.js

@@ -135,9 +135,33 @@ export async function writeClaudeSettings(paths, session) {
             "--event",
             event
         ]);
+    const toolHooks = session.fullAccessMode ? {} : {
+        PreToolUse: [
+            {
+                matcher: "Bash|Edit|Write|MultiEdit",
+                hooks: [
+                    {
+                        type: "command",
+                        command: buildHookCommand("PreToolUse")
+                    }
+                ]
+            }
+        ],
+        PostToolUse: [
+            {
+                matcher: "Bash|Edit|Write|MultiEdit",
+                hooks: [
+                    {
+                        type: "command",
+                        command: buildHookCommand("PostToolUse")
+                    }
+                ]
+            }
+        ]
+    };
     const settings = {
         permissions: {
-            defaultMode: "plan"
+            defaultMode: session.fullAccessMode ? "bypassPermissions" : "plan"
         },
         hooks: {
             SessionStart: [
@@ -151,28 +175,7 @@ export async function writeClaudeSettings(paths, session) {
                     ]
                 }
             ],
-            PreToolUse: [
-                {
-                    matcher: "Bash|Edit|Write|MultiEdit",
-                    hooks: [
-                        {
-                            type: "command",
-                            command: buildHookCommand("PreToolUse")
-                        }
-                    ]
-                }
-            ],
-            PostToolUse: [
-                {
-                    matcher: "Bash|Edit|Write|MultiEdit",
-                    hooks: [
-                        {
-                            type: "command",
-                            command: buildHookCommand("PostToolUse")
-                        }
-                    ]
-                }
-            ],
+            ...toolHooks,
             Notification: [
                 {
                     matcher: "permission_prompt|idle_prompt|auth_success",
@@ -202,35 +205,48 @@ export async function writeClaudeSettings(paths, session) {
     };
     await fs.writeFile(paths.claudeSettingsFile, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
 }
-export async function runClaudeTask(session, task, paths) {
-    const worktree = findWorktree(session, "claude");
-    const claudeSessionId = session.agentStatus.claude.sessionId ?? `${session.id}-claude`;
-    await writeClaudeSettings(paths, session);
-    const repoPrompt = await loadAgentPrompt(paths, "claude");
-    const prompt = [
-        buildAgentInstructions("claude", worktree.path, repoPrompt),
-        "",
-        buildTaskPrompt(session, task, "claude")
-    ].join("\n");
-    const result = await runCommand(session.runtime.claudeExecutable, [
+export function resolveClaudeSessionId(session) {
+    return session.agentStatus.claude.sessionId ?? session.id;
+}
+export function buildClaudeCommandArgs(session, claudeSessionId, prompt, settingsPath) {
+    const sessionArgs = session.agentStatus.claude.sessionId ? [
+        "--resume",
+        claudeSessionId
+    ] : [
+        "--session-id",
+        claudeSessionId
+    ];
+    return [
         "-p",
         "--output-format",
         "json",
         "--json-schema",
         CLAUDE_ENVELOPE_SCHEMA,
         "--settings",
-        paths.claudeSettingsFile,
-        "--permission-mode",
-        "plan",
-        ...session.agentStatus.claude.sessionId ? [
-            "--resume",
-            claudeSessionId
+        settingsPath,
+        ...session.fullAccessMode ? [
+            "--permission-mode",
+            "bypassPermissions",
+            "--dangerously-skip-permissions"
         ] : [
-            "--session-id",
-            claudeSessionId
+            "--permission-mode",
+            "plan"
         ],
+        ...sessionArgs,
         prompt
-    ], {
+    ];
+}
+export async function runClaudeTask(session, task, paths) {
+    const worktree = findWorktree(session, "claude");
+    const claudeSessionId = resolveClaudeSessionId(session);
+    await writeClaudeSettings(paths, session);
+    const repoPrompt = await loadAgentPrompt(paths, "claude");
+    const prompt = [
+        buildAgentInstructions("claude", worktree.path, repoPrompt),
+        "",
+        buildTaskPrompt(session, task, "claude")
+    ].join("\n");
+    const result = await runCommand(session.runtime.claudeExecutable, buildClaudeCommandArgs(session, claudeSessionId, prompt, paths.claudeSettingsFile), {
         cwd: worktree.path
     });
     const rawOutput = result.code === 0 ? result.stdout : `${result.stdout}\n${result.stderr}`;

package/dist/adapters/codex.js

@@ -128,19 +128,41 @@ function buildApprovalResponse(method, params, approved, remember) {
             throw new Error(`Unsupported Codex approval request: ${method}`);
     }
 }
-function buildThreadParams(session, worktree, developerInstructions) {
+export function buildThreadParams(session, worktree, developerInstructions) {
     const configuredModel = session.config.agents.codex.model.trim();
     return {
         cwd: worktree.path,
-        approvalPolicy: "on-request",
-        approvalsReviewer: "user",
-        sandbox: "workspace-write",
+        approvalPolicy: session.fullAccessMode ? "never" : "on-request",
+        sandbox: session.fullAccessMode ? "danger-full-access" : "workspace-write",
         baseInstructions: "You are Codex inside Kavi. Operate inside the assigned worktree and keep work task-scoped.",
         developerInstructions,
         model: configuredModel || null,
         ephemeral: false,
         experimentalRawEvents: false,
-        persistExtendedHistory: true
+        persistExtendedHistory: true,
+        ...session.fullAccessMode ? {} : {
+            approvalsReviewer: "user"
+        }
+    };
+}
+export function buildCodexTurnParams(session, worktree, threadId, inputText) {
+    return {
+        threadId,
+        cwd: worktree.path,
+        approvalPolicy: session.fullAccessMode ? "never" : "on-request",
+        sandbox: session.fullAccessMode ? "danger-full-access" : "workspace-write",
+        model: session.config.agents.codex.model.trim() || null,
+        outputSchema: ENVELOPE_OUTPUT_SCHEMA,
+        input: [
+            {
+                type: "text",
+                text: inputText,
+                text_elements: []
+            }
+        ],
+        ...session.fullAccessMode ? {} : {
+            approvalsReviewer: "user"
+        }
     };
 }
 async function ensureThread(client, session, paths, worktree, developerInstructions) {
@@ -163,6 +185,16 @@ async function ensureThread(client, session, paths, worktree, developerInstructi
 }
 async function handleCodexApproval(session, paths, request) {
     const descriptor = describeCodexApprovalRequest(request.method, request.params);
+    if (session.fullAccessMode) {
+        await recordEvent(paths, session.id, "approval.full_access_bypassed", {
+            agent: "codex",
+            requestId: request.id,
+            method: request.method,
+            toolName: descriptor.toolName,
+            summary: descriptor.summary
+        });
+        return buildApprovalResponse(request.method, request.params, true, true);
+    }
     const rule = await findApprovalRule(paths, {
         repoRoot: session.repoRoot,
         agent: "codex",
@@ -218,21 +250,7 @@ export async function runCodexTask(session, task, paths) {
     try {
         await client.initialize();
         const threadId = await ensureThread(client, session, paths, worktree, developerInstructions);
-        const result = await client.runTurn({
-            threadId,
-            cwd: worktree.path,
-            approvalPolicy: "on-request",
-            approvalsReviewer: "user",
-            model: session.config.agents.codex.model.trim() || null,
-            outputSchema: ENVELOPE_OUTPUT_SCHEMA,
-            input: [
-                {
-                    type: "text",
-                    text: buildTaskPrompt(session, task, "codex"),
-                    text_elements: []
-                }
-            ]
-        });
+        const result = await client.runTurn(buildCodexTurnParams(session, worktree, threadId, buildTaskPrompt(session, task, "codex")));
         const rawOutput = `${result.assistantMessage}${result.stderr ? `\n\n[stderr]\n${result.stderr}` : ""}`;
         const envelope = extractJsonObject(result.assistantMessage);
         return {

package/dist/codex-app-server.js

@@ -1,4 +1,11 @@
 import { spawn } from "node:child_process";
+export function buildCodexAppServerArgs() {
+    return [
+        "app-server",
+        "--listen",
+        "stdio://"
+    ];
+}
 function asObject(value) {
     return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
@@ -29,13 +36,7 @@ export class CodexAppServerClient {
     closePromise = null;
     constructor(runtime, cwd, onRequest){
         this.onRequest = onRequest;
-        this.child = spawn(runtime.codexExecutable, [
-            "app-server",
-            "--listen",
-            "stdio://",
-            "--session-source",
-            "cli"
-        ], {
+        this.child = spawn(runtime.codexExecutable, buildCodexAppServerArgs(), {
             cwd,
             stdio: [
                 "pipe",

package/dist/config.js

@@ -4,7 +4,7 @@ import { ensureDir, fileExists } from "./fs.js";
 import { parseToml } from "./toml.js";
 const DEFAULT_CONFIG = `version = 1
 base_branch = "main"
-validation_command = "npm test"
+validation_command = ""
 message_limit = 6
 
 [routing]
@@ -57,7 +57,7 @@ export function defaultConfig() {
     return {
         version: 1,
         baseBranch: "main",
-        validationCommand: "npm test",
+        validationCommand: "",
         messageLimit: 6,
         routing: {
             frontendKeywords: [
@@ -109,6 +109,7 @@ export async function ensureProjectScaffold(paths) {
     await ensureDir(paths.kaviDir);
     await ensureDir(paths.promptsDir);
     await ensureDir(paths.stateDir);
+    await ensureDir(paths.reportsDir);
     await ensureDir(paths.runtimeDir);
     await ensureDir(paths.runsDir);
     if (!await fileExists(paths.configFile)) {
@@ -140,7 +141,7 @@ export async function loadConfig(paths) {
     return {
         version: asNumber(parsed.version, 1),
         baseBranch: asString(parsed.base_branch, "main"),
-        validationCommand: asString(parsed.validation_command, "npm test"),
+        validationCommand: asString(parsed.validation_command, ""),
         messageLimit: asNumber(parsed.message_limit, 6),
         routing: {
             frontendKeywords: asStringArray(routing.frontend_keywords, defaultConfig().routing.frontendKeywords),

package/dist/daemon.js

@@ -9,6 +9,8 @@ import { listApprovalRequests, resolveApprovalRequest } from "./approvals.js";
 import { addDecisionRecord, releaseSupersededClaims, upsertPathClaim } from "./decision-ledger.js";
 import { getWorktreeDiffReview, listWorktreeChangedPaths } from "./git.js";
 import { nowIso } from "./paths.js";
+import { dismissOperatorRecommendation, recordRecommendationApplied, restoreOperatorRecommendation } from "./recommendations.js";
+import { loadLatestLandReport } from "./reports.js";
 import { addReviewReply, addReviewNote, autoResolveReviewNotesForCompletedTask, linkReviewFollowUpTask, reviewNotesForTask, setReviewNoteStatus, updateReviewNote } from "./reviews.js";
 import { buildAdHocTask, buildKickoffTasks } from "./router.js";
 import { loadSessionRecord, readRecentEvents, recordEvent, saveSessionRecord } from "./session.js";
@@ -171,6 +173,20 @@ export class KaviDaemon {
                         ok: true
                     }
                 };
+            case "dismissRecommendation":
+                await this.dismissRecommendationFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
+            case "restoreRecommendation":
+                await this.restoreRecommendationFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
             case "shutdown":
                 return {
                     result: {
@@ -185,6 +201,13 @@ export class KaviDaemon {
                         ok: true
                     }
                 };
+            case "setFullAccessMode":
+                await this.setFullAccessModeFromRpc(params);
+                return {
+                    result: {
+                        ok: true
+                    }
+                };
             case "taskArtifact":
                 return {
                     result: await this.getTaskArtifactFromRpc(params)
@@ -253,11 +276,13 @@ export class KaviDaemon {
                 agent: worktree.agent,
                 paths: await listWorktreeChangedPaths(worktree.path, session.baseCommit).catch(()=>[])
             })));
+        const latestLandReport = await loadLatestLandReport(this.paths);
         return {
             session,
             events,
             approvals,
-            worktreeDiffs
+            worktreeDiffs,
+            latestLandReport
         };
     }
     async runMutation(fn) {
@@ -310,14 +335,58 @@ export class KaviDaemon {
                 paths: task.claimedPaths,
                 note: task.routeReason
             });
+            if (typeof params.recommendationId === "string") {
+                recordRecommendationApplied(this.session, params.recommendationId, taskId);
+            }
             await saveSessionRecord(this.paths, this.session);
             await recordEvent(this.paths, this.session.id, "task.enqueued", {
                 owner,
-                via: "rpc"
+                via: "rpc",
+                recommendationId: typeof params.recommendationId === "string" ? params.recommendationId : null
             });
+            if (typeof params.recommendationId === "string" && (params.recommendationKind === "handoff" || params.recommendationKind === "integration" || params.recommendationKind === "ownership-config")) {
+                await recordEvent(this.paths, this.session.id, "recommendation.applied", {
+                    recommendationId: params.recommendationId,
+                    recommendationKind: params.recommendationKind,
+                    owner,
+                    taskId
+                });
+            }
             await this.publishSnapshot("task.enqueued");
         });
     }
+    async dismissRecommendationFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const recommendationId = typeof params.recommendationId === "string" ? params.recommendationId : "";
+            if (!recommendationId) {
+                throw new Error("dismissRecommendation requires a recommendationId.");
+            }
+            const reason = typeof params.reason === "string" ? params.reason : null;
+            const recommendation = dismissOperatorRecommendation(this.session, recommendationId, reason);
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "recommendation.dismissed", {
+                recommendationId,
+                kind: recommendation.kind,
+                reason
+            });
+            await this.publishSnapshot("recommendation.dismissed");
+        });
+    }
+    async restoreRecommendationFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const recommendationId = typeof params.recommendationId === "string" ? params.recommendationId : "";
+            if (!recommendationId) {
+                throw new Error("restoreRecommendation requires a recommendationId.");
+            }
+            const recommendation = restoreOperatorRecommendation(this.session, recommendationId);
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "recommendation.restored", {
+                recommendationId,
+                kind: recommendation.kind
+            });
+            await this.publishSnapshot("recommendation.restored");
+        });
+    }
     async kickoffFromRpc(params) {
         await this.runMutation(async ()=>{
             const prompt = typeof params.prompt === "string" ? params.prompt : "";
@@ -383,6 +452,29 @@ export class KaviDaemon {
             await this.publishSnapshot("approval.resolved");
         });
     }
+    async setFullAccessModeFromRpc(params) {
+        await this.runMutation(async ()=>{
+            const enabled = params.enabled === true;
+            if (this.session.fullAccessMode === enabled) {
+                return;
+            }
+            this.session.fullAccessMode = enabled;
+            addDecisionRecord(this.session, {
+                kind: "approval",
+                agent: null,
+                summary: `${enabled ? "Enabled" : "Disabled"} approve-all mode`,
+                detail: enabled ? "Future Claude and Codex turns will run with full access and without Kavi approval prompts." : "Future Claude and Codex turns will return to standard approval and sandbox behavior.",
+                metadata: {
+                    enabled
+                }
+            });
+            await saveSessionRecord(this.paths, this.session);
+            await recordEvent(this.paths, this.session.id, "session.full_access_mode_changed", {
+                enabled
+            });
+            await this.publishSnapshot("session.full_access_mode_changed");
+        });
+    }
     async getTaskArtifactFromRpc(params) {
         const taskId = typeof params.taskId === "string" ? params.taskId : "";
         if (!taskId) {
@@ -823,10 +915,22 @@ export class KaviDaemon {
                     paths: task.claimedPaths,
                     note: task.routeReason
                 });
+                if (typeof command.payload.recommendationId === "string") {
+                    recordRecommendationApplied(this.session, command.payload.recommendationId, taskId);
+                }
                 await saveSessionRecord(this.paths, this.session);
                 await recordEvent(this.paths, this.session.id, "task.enqueued", {
-                    owner
+                    owner,
+                    recommendationId: typeof command.payload.recommendationId === "string" ? command.payload.recommendationId : null
                 });
+                if (typeof command.payload.recommendationId === "string" && (command.payload.recommendationKind === "handoff" || command.payload.recommendationKind === "integration" || command.payload.recommendationKind === "ownership-config")) {
+                    await recordEvent(this.paths, this.session.id, "recommendation.applied", {
+                        recommendationId: command.payload.recommendationId,
+                        recommendationKind: command.payload.recommendationKind,
+                        owner,
+                        taskId
+                    });
+                }
                 await this.publishSnapshot("task.enqueued");
             }
         }

package/dist/git.js

@@ -342,6 +342,32 @@ export async function listWorktreeChangedPaths(worktreePath, baseCommit) {
         ...parsePathList(untracked.stdout)
     ]);
 }
+export async function resolveValidationPlan(integrationPath, validationCommand) {
+    const trimmed = validationCommand.trim();
+    if (!trimmed) {
+        return {
+            command: "",
+            status: "not_configured",
+            detail: "No validation command was configured."
+        };
+    }
+    if (trimmed === "npm test") {
+        try {
+            await fs.access(path.join(integrationPath, "package.json"));
+        } catch  {
+            return {
+                command: trimmed,
+                status: "skipped",
+                detail: 'Skipped default validation command "npm test" because package.json is not present yet.'
+            };
+        }
+    }
+    return {
+        command: trimmed,
+        status: "ran",
+        detail: `Validation ran with "${trimmed}".`
+    };
+}
 export async function getWorktreeDiffReview(agent, worktreePath, baseCommit, filePath) {
     const changedPaths = await listWorktreeChangedPaths(worktreePath, baseCommit);
     const selectedPath = filePath && changedPaths.includes(filePath) ? filePath : changedPaths[0] ?? null;
@@ -461,16 +487,20 @@ export async function landBranches(repoRoot, targetBranch, worktrees, validation
             throw new Error(merge.stderr.trim() || `Unable to merge branch ${worktree.branch} into integration branch ${integrationBranch}.`);
         }
     }
-    if (validationCommand.trim()) {
-        const validation = await runCommand("zsh", [
+    const validation = await resolveValidationPlan(integrationPath, validationCommand);
+    if (validation.status === "skipped") {
+        commandsRun.push(`SKIP ${validation.command} (${validation.detail})`);
+    }
+    if (validation.status === "ran") {
+        const validationRun = await runCommand("zsh", [
             "-lc",
-            validationCommand
+            validation.command
         ], {
             cwd: integrationPath
         });
-        commandsRun.push(validationCommand);
-        if (validation.code !== 0) {
-            throw new Error(`Validation command failed.\n${validation.stdout}\n${validation.stderr}`.trim());
+        commandsRun.push(validation.command);
+        if (validationRun.code !== 0) {
+            throw new Error(`Validation command failed.\n${validationRun.stdout}\n${validationRun.stderr}`.trim());
         }
     }
     const currentBranch = await getCurrentBranch(repoRoot).catch(()=>"");
@@ -500,10 +530,35 @@ export async function landBranches(repoRoot, targetBranch, worktrees, validation
             throw new Error(updateRef.stderr.trim() || `Unable to advance ${targetBranch}; it changed while landing was in progress.`);
         }
     }
+    const landedHead = await getBranchCommit(repoRoot, targetBranch);
+    for (const worktree of worktrees){
+        const reset = await runCommand("git", [
+            "reset",
+            "--hard",
+            landedHead
+        ], {
+            cwd: worktree.path
+        });
+        commandsRun.push(`git -C ${worktree.path} reset --hard ${landedHead}`);
+        if (reset.code !== 0) {
+            throw new Error(reset.stderr.trim() || `Unable to reset managed worktree ${worktree.path} to landed head ${landedHead}.`);
+        }
+        const clean = await runCommand("git", [
+            "clean",
+            "-fd"
+        ], {
+            cwd: worktree.path
+        });
+        commandsRun.push(`git -C ${worktree.path} clean -fd`);
+        if (clean.code !== 0) {
+            throw new Error(clean.stderr.trim() || `Unable to clean managed worktree ${worktree.path}.`);
+        }
+    }
     return {
         commandsRun,
         integrationBranch,
         integrationPath,
+        validation,
         snapshotCommits
     };
 }