@mandipadk7/kavi 0.1.4 → 0.1.5

package/README.md

@@ -10,14 +10,14 @@ Current capabilities:
 - `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 resume`: reopen the operator console for the current repo session.
-- `kavi status`: inspect session health and task counts from any terminal.
+- `kavi status`: inspect session health, task counts, and configured routing ownership rules from any terminal.
 - `kavi paths`: inspect resolved repo-local, user-local, worktree, and runtime paths.
 - `kavi task`: enqueue a task for `codex`, `claude`, or `auto` routing.
 - `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.
 - `kavi claims`: inspect active or historical path claims.
-- `kavi reviews`: inspect persisted operator review threads and linked follow-up tasks.
+- `kavi reviews`: inspect persisted operator review threads and linked follow-up tasks, with filters for agent, assignee, disposition, and status.
 - `kavi approvals`: inspect the approval inbox.
 - `kavi approve` and `kavi deny`: resolve a pending approval request, optionally with `--remember`.
 - `kavi events`: inspect recent daemon and task events.
@@ -33,15 +33,18 @@ Runtime model:
 - 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.
 - 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.
+- 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.
 
 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.
 - `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.
 - 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.
+- 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.
 - 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.
 

package/dist/daemon.js

@@ -6,7 +6,7 @@ import { buildPeerMessages as buildClaudePeerMessages, runClaudeTask } from "./a
 import { buildPeerMessages as buildCodexPeerMessages, runCodexTask } from "./adapters/codex.js";
 import { buildDecisionReplay } from "./adapters/shared.js";
 import { listApprovalRequests, resolveApprovalRequest } from "./approvals.js";
-import { addDecisionRecord, upsertPathClaim } from "./decision-ledger.js";
+import { addDecisionRecord, releaseSupersededClaims, upsertPathClaim } from "./decision-ledger.js";
 import { getWorktreeDiffReview, listWorktreeChangedPaths } from "./git.js";
 import { nowIso } from "./paths.js";
 import { addReviewReply, addReviewNote, autoResolveReviewNotesForCompletedTask, linkReviewFollowUpTask, reviewNotesForTask, setReviewNoteStatus, updateReviewNote } from "./reviews.js";
@@ -284,6 +284,9 @@ export class KaviDaemon {
             const taskId = `task-${commandId}`;
             const task = buildAdHocTask(owner, prompt, taskId, {
                 routeReason: typeof params.routeReason === "string" ? params.routeReason : null,
+                routeStrategy: params.routeStrategy === "manual" || params.routeStrategy === "keyword" || params.routeStrategy === "ai" || params.routeStrategy === "path-claim" || params.routeStrategy === "fallback" ? params.routeStrategy : null,
+                routeConfidence: typeof params.routeConfidence === "number" ? params.routeConfidence : null,
+                routeMetadata: params.routeMetadata && typeof params.routeMetadata === "object" && !Array.isArray(params.routeMetadata) ? params.routeMetadata : {},
                 claimedPaths: Array.isArray(params.claimedPaths) ? params.claimedPaths.map((item)=>String(item)) : []
             });
             this.session.tasks.push(task);
@@ -296,7 +299,8 @@ export class KaviDaemon {
                 metadata: {
                     strategy: typeof params.routeStrategy === "string" ? params.routeStrategy : "unknown",
                     confidence: typeof params.routeConfidence === "number" ? params.routeConfidence : null,
-                    claimedPaths: task.claimedPaths
+                    claimedPaths: task.claimedPaths,
+                    routeMetadata: params.routeMetadata && typeof params.routeMetadata === "object" && !Array.isArray(params.routeMetadata) ? params.routeMetadata : {}
                 }
             });
             upsertPathClaim(this.session, {
@@ -621,6 +625,13 @@ export class KaviDaemon {
             promptLines.push(`Focus the change in ${note.filePath} and update the managed worktree accordingly.`);
             const task = buildAdHocTask(owner, promptLines.join(" "), taskId, {
                 routeReason: mode === "handoff" ? `Operator handed off review note ${note.id} to ${owner}.` : `Operator created a follow-up task from review note ${note.id}.`,
+                routeStrategy: "manual",
+                routeConfidence: 1,
+                routeMetadata: {
+                    source: "review-follow-up",
+                    mode,
+                    reviewNoteId: note.id
+                },
                 claimedPaths: [
                     note.filePath
                 ]
@@ -786,6 +797,9 @@ export class KaviDaemon {
                 const taskId = `task-${command.id}`;
                 const task = buildAdHocTask(owner, command.payload.prompt, taskId, {
                     routeReason: typeof command.payload.routeReason === "string" ? command.payload.routeReason : null,
+                    routeStrategy: command.payload.routeStrategy === "manual" || command.payload.routeStrategy === "keyword" || command.payload.routeStrategy === "ai" || command.payload.routeStrategy === "path-claim" || command.payload.routeStrategy === "fallback" ? command.payload.routeStrategy : null,
+                    routeConfidence: typeof command.payload.routeConfidence === "number" ? command.payload.routeConfidence : null,
+                    routeMetadata: command.payload.routeMetadata && typeof command.payload.routeMetadata === "object" && !Array.isArray(command.payload.routeMetadata) ? command.payload.routeMetadata : {},
                     claimedPaths: Array.isArray(command.payload.claimedPaths) ? command.payload.claimedPaths.map((item)=>String(item)) : []
                 });
                 this.session.tasks.push(task);
@@ -798,7 +812,8 @@ export class KaviDaemon {
                     metadata: {
                         strategy: typeof command.payload.routeStrategy === "string" ? command.payload.routeStrategy : "unknown",
                         confidence: typeof command.payload.routeConfidence === "number" ? command.payload.routeConfidence : null,
-                        claimedPaths: task.claimedPaths
+                        claimedPaths: task.claimedPaths,
+                        routeMetadata: command.payload.routeMetadata && typeof command.payload.routeMetadata === "object" && !Array.isArray(command.payload.routeMetadata) ? command.payload.routeMetadata : {}
                     }
                 });
                 upsertPathClaim(this.session, {
@@ -849,18 +864,7 @@ export class KaviDaemon {
             task.summary = envelope.summary;
             task.updatedAt = new Date().toISOString();
             if (task.owner === "codex" || task.owner === "claude") {
-                const worktree = this.session.worktrees.find((item)=>item.agent === task.owner);
-                if (worktree) {
-                    const changedPaths = await listWorktreeChangedPaths(worktree.path, this.session.baseCommit);
-                    task.claimedPaths = changedPaths;
-                    upsertPathClaim(this.session, {
-                        taskId: task.id,
-                        agent: task.owner,
-                        source: "diff",
-                        paths: changedPaths,
-                        note: task.summary
-                    });
-                }
+                await this.refreshTaskClaims(task);
             }
             addDecisionRecord(this.session, {
                 kind: "task",
@@ -901,6 +905,9 @@ export class KaviDaemon {
                 status: task.status,
                 summary: task.summary,
                 routeReason: task.routeReason,
+                routeStrategy: task.routeStrategy,
+                routeConfidence: task.routeConfidence,
+                routeMetadata: task.routeMetadata,
                 claimedPaths: task.claimedPaths,
                 decisionReplay,
                 rawOutput,
@@ -932,18 +939,7 @@ export class KaviDaemon {
             task.summary = error instanceof Error ? error.message : String(error);
             task.updatedAt = new Date().toISOString();
             if (task.owner === "codex" || task.owner === "claude") {
-                const worktree = this.session.worktrees.find((item)=>item.agent === task.owner);
-                if (worktree) {
-                    const changedPaths = await listWorktreeChangedPaths(worktree.path, this.session.baseCommit);
-                    task.claimedPaths = changedPaths;
-                    upsertPathClaim(this.session, {
-                        taskId: task.id,
-                        agent: task.owner,
-                        source: "diff",
-                        paths: changedPaths,
-                        note: task.summary
-                    });
-                }
+                await this.refreshTaskClaims(task);
             }
             addDecisionRecord(this.session, {
                 kind: "task",
@@ -968,6 +964,9 @@ export class KaviDaemon {
                 status: task.status,
                 summary: task.summary,
                 routeReason: task.routeReason,
+                routeStrategy: task.routeStrategy,
+                routeConfidence: task.routeConfidence,
+                routeMetadata: task.routeMetadata,
                 claimedPaths: task.claimedPaths,
                 decisionReplay,
                 rawOutput: null,
@@ -994,6 +993,60 @@ export class KaviDaemon {
             summary
         };
     }
+    async refreshTaskClaims(task) {
+        if (task.owner !== "codex" && task.owner !== "claude") {
+            return;
+        }
+        const worktree = this.session.worktrees.find((item)=>item.agent === task.owner);
+        if (!worktree) {
+            return;
+        }
+        const changedPaths = await listWorktreeChangedPaths(worktree.path, this.session.baseCommit);
+        const hadClaimedSurface = task.claimedPaths.length > 0 || this.session.pathClaims.some((claim)=>claim.taskId === task.id && claim.status === "active");
+        task.claimedPaths = changedPaths;
+        const claim = upsertPathClaim(this.session, {
+            taskId: task.id,
+            agent: task.owner,
+            source: "diff",
+            paths: changedPaths,
+            note: task.summary
+        });
+        if (claim && changedPaths.length > 0) {
+            const releasedClaims = releaseSupersededClaims(this.session, {
+                agent: task.owner,
+                taskId: task.id,
+                paths: changedPaths,
+                note: `Superseded by newer ${task.owner} diff claim from task ${task.id}.`
+            });
+            for (const releasedClaim of releasedClaims){
+                addDecisionRecord(this.session, {
+                    kind: "route",
+                    agent: task.owner,
+                    taskId: releasedClaim.taskId,
+                    summary: `Released superseded claim ${releasedClaim.id}`,
+                    detail: releasedClaim.paths.join(", ") || "No claimed paths.",
+                    metadata: {
+                        claimId: releasedClaim.id,
+                        supersededByTaskId: task.id,
+                        supersededByPaths: changedPaths
+                    }
+                });
+            }
+            return;
+        }
+        if (changedPaths.length === 0 && hadClaimedSurface) {
+            addDecisionRecord(this.session, {
+                kind: "route",
+                agent: task.owner,
+                taskId: task.id,
+                summary: `Released empty claim surface for ${task.id}`,
+                detail: "Task finished without a remaining worktree diff for its claimed paths.",
+                metadata: {
+                    releaseReason: "empty-diff-claim"
+                }
+            });
+        }
+    }
 }
 
 

package/dist/decision-ledger.js

@@ -1,11 +1,26 @@
+import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { nowIso } from "./paths.js";
 const MAX_DECISIONS = 80;
 function normalizePaths(paths) {
     return [
-        ...new Set(paths.map((item)=>item.trim()).filter(Boolean))
+        ...new Set(paths.map(normalizePath).filter(Boolean))
     ].sort();
 }
+function normalizePath(value) {
+    const trimmed = value.trim().replaceAll("\\", "/");
+    const withoutPrefix = trimmed.startsWith("./") ? trimmed.slice(2) : trimmed;
+    const normalized = path.posix.normalize(withoutPrefix);
+    return normalized === "." ? "" : normalized.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+function pathOverlaps(left, right) {
+    const leftPath = normalizePath(left);
+    const rightPath = normalizePath(right);
+    if (!leftPath || !rightPath) {
+        return false;
+    }
+    return leftPath === rightPath || leftPath.startsWith(`${rightPath}/`) || rightPath.startsWith(`${leftPath}/`);
+}
 export function addDecisionRecord(session, input) {
     const record = {
         id: randomUUID(),
@@ -63,12 +78,53 @@ export function upsertPathClaim(session, input) {
 export function activePathClaims(session) {
     return session.pathClaims.filter((claim)=>claim.status === "active" && claim.paths.length > 0);
 }
+export function releasePathClaims(session, input = {}) {
+    const taskIds = input.taskIds ? new Set(input.taskIds) : null;
+    const released = [];
+    for (const claim of session.pathClaims){
+        if (claim.status !== "active") {
+            continue;
+        }
+        if (taskIds && !taskIds.has(claim.taskId)) {
+            continue;
+        }
+        claim.status = "released";
+        claim.updatedAt = nowIso();
+        if (input.note !== undefined) {
+            claim.note = input.note;
+        }
+        released.push(claim);
+    }
+    return released;
+}
+export function releaseSupersededClaims(session, input) {
+    const normalizedPaths = normalizePaths(input.paths);
+    if (normalizedPaths.length === 0) {
+        return [];
+    }
+    const released = [];
+    for (const claim of session.pathClaims){
+        if (claim.status !== "active" || claim.agent !== input.agent || claim.taskId === input.taskId) {
+            continue;
+        }
+        if (!claim.paths.some((item)=>normalizedPaths.some((candidate)=>pathOverlaps(item, candidate)))) {
+            continue;
+        }
+        claim.status = "released";
+        claim.updatedAt = nowIso();
+        if (input.note !== undefined) {
+            claim.note = input.note;
+        }
+        released.push(claim);
+    }
+    return released;
+}
 export function findClaimConflicts(session, owner, claimedPaths) {
     const normalizedPaths = normalizePaths(claimedPaths);
     if (normalizedPaths.length === 0) {
         return [];
     }
-    return activePathClaims(session).filter((claim)=>claim.agent !== owner && claim.paths.some((item)=>normalizedPaths.includes(item)));
+    return activePathClaims(session).filter((claim)=>claim.agent !== owner && claim.paths.some((item)=>normalizedPaths.some((candidate)=>pathOverlaps(item, candidate))));
 }
 
 

package/dist/doctor.js

@@ -1,3 +1,5 @@
+import path from "node:path";
+import { loadConfig } from "./config.js";
 import { fileExists } from "./fs.js";
 import { runCommand } from "./process.js";
 import { hasSupportedNode, minimumNodeMajor, resolveSessionRuntime } from "./runtime.js";
@@ -19,12 +21,81 @@ export function parseClaudeAuthStatus(output) {
         };
     }
 }
+function normalizeRoutingPathRule(value) {
+    const trimmed = value.trim().replaceAll("\\", "/");
+    const withoutPrefix = trimmed.startsWith("./") ? trimmed.slice(2) : trimmed;
+    const normalized = path.posix.normalize(withoutPrefix);
+    return normalized === "." ? "" : normalized.replace(/^\/+/, "").replace(/\/+$/, "");
+}
+export function validateRoutingPathRules(config) {
+    const issues = [];
+    const codexPaths = config.routing.codexPaths.map(normalizeRoutingPathRule);
+    const claudePaths = config.routing.claudePaths.map(normalizeRoutingPathRule);
+    const rawRules = [
+        ...config.routing.codexPaths.map((rule)=>({
+                owner: "codex",
+                raw: rule,
+                normalized: normalizeRoutingPathRule(rule)
+            })),
+        ...config.routing.claudePaths.map((rule)=>({
+                owner: "claude",
+                raw: rule,
+                normalized: normalizeRoutingPathRule(rule)
+            }))
+    ];
+    const blankRules = [
+        ...codexPaths,
+        ...claudePaths
+    ].filter((rule)=>!rule);
+    if (blankRules.length > 0) {
+        issues.push("Ownership path rules must not be empty.");
+    }
+    const absoluteRules = rawRules.filter(({ raw })=>{
+        const trimmed = raw.trim();
+        return trimmed.startsWith("/") || /^[A-Za-z]:[\\/]/.test(trimmed);
+    }).map(({ owner, raw })=>`${owner}:${raw}`);
+    if (absoluteRules.length > 0) {
+        issues.push(`Ownership path rules must be repo-relative, not absolute: ${absoluteRules.join(", ")}`);
+    }
+    const parentTraversalRules = rawRules.filter(({ normalized })=>normalized === ".." || normalized.startsWith("../")).map(({ owner, raw })=>`${owner}:${raw}`);
+    if (parentTraversalRules.length > 0) {
+        issues.push(`Ownership path rules must stay inside the repo root: ${parentTraversalRules.join(", ")}`);
+    }
+    const duplicateRules = (rules, owner)=>{
+        const seen = new Set();
+        const duplicates = new Set();
+        for (const rule of rules){
+            if (!rule) {
+                continue;
+            }
+            if (seen.has(rule)) {
+                duplicates.add(rule);
+            }
+            seen.add(rule);
+        }
+        if (duplicates.size > 0) {
+            issues.push(`${owner} has duplicate ownership rules: ${[
+                ...duplicates
+            ].join(", ")}`);
+        }
+    };
+    duplicateRules(codexPaths, "codex");
+    duplicateRules(claudePaths, "claude");
+    const overlappingRules = codexPaths.filter((rule)=>rule && claudePaths.includes(rule));
+    if (overlappingRules.length > 0) {
+        issues.push(`codex_paths and claude_paths overlap on the same exact rules: ${[
+            ...new Set(overlappingRules)
+        ].join(", ")}`);
+    }
+    return issues;
+}
 function normalizeVersion(output) {
     return output.trim().split(/\s+/).slice(-1)[0] ?? output.trim();
 }
 export async function runDoctor(repoRoot, paths) {
     const checks = [];
     const runtime = await resolveSessionRuntime(paths);
+    const config = await loadConfig(paths);
     const nodeVersion = await runCommand(runtime.nodeExecutable, [
         "--version"
     ], {
@@ -104,6 +175,12 @@ export async function runDoctor(repoRoot, paths) {
         ok: true,
         detail: homeConfigCheck ? "present" : "will be created on demand"
     });
+    const routingRuleIssues = validateRoutingPathRules(config);
+    checks.push({
+        name: "routing-path-rules",
+        ok: routingRuleIssues.length === 0,
+        detail: routingRuleIssues.length === 0 ? "valid" : routingRuleIssues.join("; ")
+    });
     return checks;
 }
 

package/dist/main.js

@@ -6,14 +6,14 @@ import { createApprovalRequest, describeToolUse, findApprovalRule, listApprovalR
 import { appendCommand } from "./command-queue.js";
 import { ensureHomeConfig, ensureProjectScaffold, loadConfig } from "./config.js";
 import { KaviDaemon } from "./daemon.js";
-import { addDecisionRecord, upsertPathClaim } from "./decision-ledger.js";
+import { addDecisionRecord, 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 { buildSessionId, resolveAppPaths } from "./paths.js";
 import { isProcessAlive, spawnDetachedNode } from "./process.js";
 import { pingRpc, readSnapshot, rpcEnqueueTask, rpcNotifyExternalUpdate, rpcKickoff, rpcRecentEvents, rpcResolveApproval, rpcShutdown, rpcTaskArtifact } from "./rpc.js";
-import { markReviewNotesLandedForTasks } from "./reviews.js";
+import { filterReviewNotes, markReviewNotesLandedForTasks } from "./reviews.js";
 import { resolveSessionRuntime } from "./runtime.js";
 import { buildAdHocTask, extractPromptPathHints, routeTask } from "./router.js";
 import { createSessionRecord, loadSessionRecord, readRecentEvents, recordEvent, saveSessionRecord, sessionExists, sessionHeartbeatAgeMs } from "./session.js";
@@ -46,6 +46,13 @@ function getGoal(args) {
     });
     return filtered.length > 0 ? filtered.join(" ") : null;
 }
+function getOptionalFilter(args, name) {
+    const value = getFlag(args, name);
+    if (!value || value.startsWith("--")) {
+        return null;
+    }
+    return value;
+}
 async function readStdinText() {
     if (process.stdin.isTTY) {
         return "";
@@ -72,7 +79,7 @@ function renderUsage() {
         "  kavi task-output <task-id|latest> [--json]",
         "  kavi decisions [--json] [--limit N]",
         "  kavi claims [--json] [--all]",
-        "  kavi reviews [--json] [--all]",
+        "  kavi reviews [--json] [--all] [--agent codex|claude] [--assignee codex|claude|operator|unassigned] [--status open|resolved] [--disposition approve|concern|question|note|accepted_risk|wont_fix]",
         "  kavi approvals [--json] [--all]",
         "  kavi approve <request-id|latest> [--remember]",
         "  kavi deny <request-id|latest> [--remember]",
@@ -349,6 +356,10 @@ async function commandStatus(cwd, args) {
         pathClaimCounts: {
             active: session.pathClaims.filter((claim)=>claim.status === "active").length
         },
+        routingOwnership: {
+            codexPaths: session.config.routing.codexPaths,
+            claudePaths: session.config.routing.claudePaths
+        },
         worktrees: session.worktrees
     };
     if (args.includes("--json")) {
@@ -368,6 +379,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(`Routing ownership: codex=${payload.routingOwnership.codexPaths.join(", ") || "-"} | claude=${payload.routingOwnership.claudePaths.join(", ") || "-"}`);
     for (const worktree of payload.worktrees){
         console.log(`- ${worktree.agent}: ${worktree.path}`);
     }
@@ -429,13 +441,18 @@ async function commandTask(cwd, args) {
         strategy: "manual",
         confidence: 1,
         reason: `User explicitly assigned the task to ${requestedAgent}.`,
-        claimedPaths: extractPromptPathHints(prompt)
+        claimedPaths: extractPromptPathHints(prompt),
+        metadata: {
+            manualAssignment: true,
+            requestedAgent
+        }
     } : await routeTask(prompt, session, paths);
     if (rpcSnapshot) {
         await rpcEnqueueTask(paths, {
             owner: routeDecision.owner,
             prompt,
             routeReason: routeDecision.reason,
+            routeMetadata: routeDecision.metadata,
             claimedPaths: routeDecision.claimedPaths,
             routeStrategy: routeDecision.strategy,
             routeConfidence: routeDecision.confidence
@@ -445,6 +462,7 @@ async function commandTask(cwd, args) {
             owner: routeDecision.owner,
             prompt,
             routeReason: routeDecision.reason,
+            routeMetadata: routeDecision.metadata,
             claimedPaths: routeDecision.claimedPaths,
             routeStrategy: routeDecision.strategy,
             routeConfidence: routeDecision.confidence
@@ -455,7 +473,8 @@ async function commandTask(cwd, args) {
         prompt,
         strategy: routeDecision.strategy,
         confidence: routeDecision.confidence,
-        claimedPaths: routeDecision.claimedPaths
+        claimedPaths: routeDecision.claimedPaths,
+        routeMetadata: routeDecision.metadata
     });
     console.log(`Queued task for ${routeDecision.owner}: ${prompt}\nRoute: ${routeDecision.strategy} (${routeDecision.confidence.toFixed(2)}) ${routeDecision.reason}`);
 }
@@ -477,6 +496,9 @@ async function commandTasks(cwd, args) {
             updatedAt: task.updatedAt,
             summary: task.summary,
             routeReason: task.routeReason,
+            routeStrategy: task.routeStrategy,
+            routeConfidence: task.routeConfidence,
+            routeMetadata: task.routeMetadata,
             claimedPaths: task.claimedPaths,
             hasArtifact: artifactMap.has(task.id)
         }));
@@ -488,8 +510,11 @@ async function commandTasks(cwd, args) {
         console.log(`${task.id} | ${task.owner} | ${task.status} | artifact=${task.hasArtifact ? "yes" : "no"}`);
         console.log(`  title: ${task.title}`);
         console.log(`  updated: ${task.updatedAt}`);
-        console.log(`  route: ${task.routeReason ?? "-"}`);
+        console.log(`  route: ${task.routeStrategy ?? "-"}${task.routeConfidence === null ? "" : ` (${task.routeConfidence.toFixed(2)})`} ${task.routeReason ?? "-"}`);
         console.log(`  paths: ${task.claimedPaths.join(", ") || "-"}`);
+        if (Object.keys(task.routeMetadata).length > 0) {
+            console.log(`  route-meta: ${JSON.stringify(task.routeMetadata)}`);
+        }
         console.log(`  summary: ${task.summary ?? "-"}`);
     }
 }
@@ -529,7 +554,8 @@ async function commandTaskOutput(cwd, args) {
     console.log(`Started: ${artifact.startedAt}`);
     console.log(`Finished: ${artifact.finishedAt}`);
     console.log(`Summary: ${artifact.summary ?? "-"}`);
-    console.log(`Route: ${artifact.routeReason ?? "-"}`);
+    console.log(`Route: ${artifact.routeStrategy ?? "-"}${artifact.routeConfidence === null ? "" : ` (${artifact.routeConfidence.toFixed(2)})`} ${artifact.routeReason ?? "-"}`);
+    console.log(`Route Metadata: ${JSON.stringify(artifact.routeMetadata ?? {})}`);
     console.log(`Claimed paths: ${artifact.claimedPaths.join(", ") || "-"}`);
     console.log(`Error: ${artifact.error ?? "-"}`);
     console.log("Decision Replay:");
@@ -577,6 +603,9 @@ async function commandDecisions(cwd, args) {
         console.log(`${decision.createdAt} | ${decision.kind} | ${decision.agent ?? "-"} | ${decision.summary}`);
         console.log(`  task: ${decision.taskId ?? "-"}`);
         console.log(`  detail: ${decision.detail}`);
+        if (Object.keys(decision.metadata).length > 0) {
+            console.log(`  metadata: ${JSON.stringify(decision.metadata)}`);
+        }
     }
 }
 async function commandClaims(cwd, args) {
@@ -603,15 +632,19 @@ async function commandReviews(cwd, args) {
     const { paths } = await requireSession(cwd);
     const rpcSnapshot = await tryRpcSnapshot(paths);
     const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
-    const notes = args.includes("--all") ? [
-        ...session.reviewNotes
-    ] : session.reviewNotes.filter((note)=>note.status === "open");
+    const filters = {
+        agent: getOptionalFilter(args, "--agent"),
+        assignee: getOptionalFilter(args, "--assignee"),
+        disposition: getOptionalFilter(args, "--disposition"),
+        status: getOptionalFilter(args, "--status") ?? (args.includes("--all") ? null : "open")
+    };
+    const notes = filterReviewNotes(session.reviewNotes, filters);
     if (args.includes("--json")) {
         console.log(JSON.stringify(notes, null, 2));
         return;
     }
     if (notes.length === 0) {
-        console.log("No review notes recorded.");
+        console.log("No review notes matched the current filters.");
         return;
     }
     for (const note of notes){
@@ -748,6 +781,12 @@ async function commandLand(cwd) {
             ].join("\n"), taskId, {
                 title: "Resolve integration overlap",
                 routeReason: "Created by kavi land because multiple agents changed the same paths.",
+                routeStrategy: "manual",
+                routeConfidence: 1,
+                routeMetadata: {
+                    source: "land-overlap",
+                    targetBranch
+                },
                 claimedPaths: overlappingPaths
             }));
             upsertPathClaim(session, {
@@ -788,6 +827,23 @@ async function commandLand(cwd) {
         snapshotCommits: result.snapshotCommits,
         commands: result.commandsRun
     });
+    const releasedClaims = releasePathClaims(session, {
+        note: `Released after landing into ${targetBranch}.`
+    });
+    for (const claim of releasedClaims){
+        addDecisionRecord(session, {
+            kind: "integration",
+            agent: claim.agent,
+            taskId: claim.taskId,
+            summary: `Released path claim ${claim.id}`,
+            detail: claim.paths.join(", ") || "No claimed paths.",
+            metadata: {
+                claimId: claim.id,
+                targetBranch,
+                releaseReason: "land.completed"
+            }
+        });
+    }
     const landedReviewNotes = markReviewNotesLandedForTasks(session, session.tasks.filter((task)=>task.status === "completed").map((task)=>task.id));
     for (const note of landedReviewNotes){
         addDecisionRecord(session, {

package/dist/reviews.js

@@ -72,6 +72,30 @@ export function reviewNotesForPath(session, agent, filePath, hunkIndex) {
         return note.hunkIndex === hunkIndex;
     });
 }
+export function reviewNoteMatchesFilters(note, filters) {
+    if (filters.agent && note.agent !== filters.agent) {
+        return false;
+    }
+    if (filters.assignee) {
+        if (filters.assignee === "unassigned") {
+            if (note.assignee !== null) {
+                return false;
+            }
+        } else if (note.assignee !== filters.assignee) {
+            return false;
+        }
+    }
+    if (filters.disposition && note.disposition !== filters.disposition) {
+        return false;
+    }
+    if (filters.status && note.status !== filters.status) {
+        return false;
+    }
+    return true;
+}
+export function filterReviewNotes(notes, filters) {
+    return notes.filter((note)=>reviewNoteMatchesFilters(note, filters));
+}
 export function updateReviewNote(session, noteId, input) {
     const note = session.reviewNotes.find((item)=>item.id === noteId) ?? null;
     if (!note) {

package/dist/router.js

@@ -44,6 +44,9 @@ function normalizeClaimedPaths(paths) {
         ...new Set(paths.map((item)=>item.trim()).filter(Boolean))
     ].sort();
 }
+function buildRouteMetadata(input = {}) {
+    return input;
+}
 function normalizePathPattern(value) {
     const trimmed = value.trim().replaceAll("\\", "/");
     const withoutPrefix = trimmed.startsWith("./") ? trimmed.slice(2) : trimmed;
@@ -84,13 +87,20 @@ function buildPathOwnershipDecision(prompt, config) {
         return null;
     }
     const owner = codexMatches > claudeMatches ? "codex" : "claude";
-    const matchedPatterns = owner === "codex" ? config.routing.codexPaths : config.routing.claudePaths;
+    const ownerPatterns = owner === "codex" ? config.routing.codexPaths : config.routing.claudePaths;
+    const matchedPatterns = ownerPatterns.filter((pattern)=>claimedPaths.some((filePath)=>matchesPattern(filePath, pattern)));
     return {
         owner,
         strategy: "manual",
         confidence: 0.97,
         reason: `Matched explicit ${owner} path ownership rules for: ${claimedPaths.join(", ")}.`,
-        claimedPaths
+        claimedPaths,
+        metadata: buildRouteMetadata({
+            ownershipSource: "config-routing-paths",
+            matchedPatterns,
+            codexMatches,
+            claudeMatches
+        })
     };
 }
 export function extractPromptPathHints(prompt) {
@@ -131,7 +141,11 @@ function buildKeywordDecision(prompt, config) {
             strategy: "keyword",
             confidence: 0.92,
             reason: "Matched frontend and UX routing keywords.",
-            claimedPaths
+            claimedPaths,
+            metadata: buildRouteMetadata({
+                matchedKeywordSet: "frontend",
+                promptHints: claimedPaths
+            })
         };
     }
     if (backend && !frontend) {
@@ -140,7 +154,11 @@ function buildKeywordDecision(prompt, config) {
             strategy: "keyword",
             confidence: 0.92,
             reason: "Matched backend and architecture routing keywords.",
-            claimedPaths
+            claimedPaths,
+            metadata: buildRouteMetadata({
+                matchedKeywordSet: "backend",
+                promptHints: claimedPaths
+            })
         };
     }
     return null;
@@ -214,7 +232,11 @@ async function routeWithCodexAi(prompt, session) {
             strategy: "ai",
             confidence,
             reason,
-            claimedPaths
+            claimedPaths,
+            metadata: buildRouteMetadata({
+                router: "codex-ai",
+                promptHints: extractPromptPathHints(prompt)
+            })
         };
     } finally{
         await client.close();
@@ -235,7 +257,18 @@ function applyClaimRouting(session, decision) {
         strategy: "path-claim",
         confidence: 1,
         reason: `Re-routed to ${owner} because active path claims overlap: ${overlappingPaths.join(", ")}`,
-        claimedPaths: decision.claimedPaths.length > 0 ? decision.claimedPaths : overlappingPaths
+        claimedPaths: decision.claimedPaths.length > 0 ? decision.claimedPaths : overlappingPaths,
+        metadata: buildRouteMetadata({
+            ...decision.metadata,
+            reroutedFrom: decision.owner,
+            conflictingClaims: conflicts.map((claim)=>({
+                    taskId: claim.taskId,
+                    agent: claim.agent,
+                    source: claim.source,
+                    paths: claim.paths
+                })),
+            overlappingPaths
+        })
     };
 }
 export async function routeTask(prompt, session, _paths) {
@@ -256,7 +289,11 @@ export async function routeTask(prompt, session, _paths) {
             strategy: "fallback",
             confidence: 0.4,
             reason: error instanceof Error ? `AI routing failed, defaulted to Codex: ${error.message}` : "AI routing failed, defaulted to Codex.",
-            claimedPaths: extractPromptPathHints(prompt)
+            claimedPaths: extractPromptPathHints(prompt),
+            metadata: buildRouteMetadata({
+                router: "fallback",
+                error: error instanceof Error ? error.message : String(error)
+            })
         });
     }
 }
@@ -273,6 +310,12 @@ export function buildKickoffTasks(goal) {
             updatedAt: timestamp,
             summary: null,
             routeReason: "Kickoff task reserved for Codex planning.",
+            routeStrategy: "manual",
+            routeConfidence: 1,
+            routeMetadata: buildRouteMetadata({
+                kickoff: true,
+                reservedFor: "codex"
+            }),
             claimedPaths: []
         },
         {
@@ -285,6 +328,12 @@ export function buildKickoffTasks(goal) {
             updatedAt: timestamp,
             summary: null,
             routeReason: "Kickoff task reserved for Claude intent and UX interpretation.",
+            routeStrategy: "manual",
+            routeConfidence: 1,
+            routeMetadata: buildRouteMetadata({
+                kickoff: true,
+                reservedFor: "claude"
+            }),
             claimedPaths: []
         }
     ];
@@ -301,6 +350,9 @@ export function buildAdHocTask(owner, prompt, taskId, options = {}) {
         updatedAt: timestamp,
         summary: null,
         routeReason: options.routeReason ?? null,
+        routeStrategy: options.routeStrategy ?? null,
+        routeConfidence: typeof options.routeConfidence === "number" && Number.isFinite(options.routeConfidence) ? options.routeConfidence : null,
+        routeMetadata: options.routeMetadata ?? {},
         claimedPaths: normalizeClaimedPaths(options.claimedPaths ?? [])
     };
 }

package/dist/rpc.js

@@ -96,6 +96,7 @@ export async function rpcEnqueueTask(paths, params) {
         owner: params.owner,
         prompt: params.prompt,
         routeReason: params.routeReason,
+        routeMetadata: params.routeMetadata,
         claimedPaths: params.claimedPaths,
         routeStrategy: params.routeStrategy,
         routeConfidence: params.routeConfidence

package/dist/session.js

@@ -52,6 +52,9 @@ export async function loadSessionRecord(paths) {
     record.tasks = Array.isArray(record.tasks) ? record.tasks.map((task)=>({
             ...task,
             routeReason: typeof task.routeReason === "string" ? task.routeReason : null,
+            routeStrategy: task.routeStrategy === "manual" || task.routeStrategy === "keyword" || task.routeStrategy === "ai" || task.routeStrategy === "path-claim" || task.routeStrategy === "fallback" ? task.routeStrategy : null,
+            routeConfidence: typeof task.routeConfidence === "number" && Number.isFinite(task.routeConfidence) ? task.routeConfidence : null,
+            routeMetadata: task.routeMetadata && typeof task.routeMetadata === "object" && !Array.isArray(task.routeMetadata) ? task.routeMetadata : {},
             claimedPaths: Array.isArray(task.claimedPaths) ? task.claimedPaths.map((item)=>String(item)) : []
         })) : [];
     record.decisions = Array.isArray(record.decisions) ? record.decisions : [];

package/dist/task-artifacts.js

@@ -8,6 +8,9 @@ function normalizeArtifact(artifact) {
     return {
         ...artifact,
         routeReason: typeof artifact.routeReason === "string" ? artifact.routeReason : null,
+        routeStrategy: artifact.routeStrategy === "manual" || artifact.routeStrategy === "keyword" || artifact.routeStrategy === "ai" || artifact.routeStrategy === "path-claim" || artifact.routeStrategy === "fallback" ? artifact.routeStrategy : null,
+        routeConfidence: typeof artifact.routeConfidence === "number" && Number.isFinite(artifact.routeConfidence) ? artifact.routeConfidence : null,
+        routeMetadata: artifact.routeMetadata && typeof artifact.routeMetadata === "object" && !Array.isArray(artifact.routeMetadata) ? artifact.routeMetadata : {},
         claimedPaths: Array.isArray(artifact.claimedPaths) ? artifact.claimedPaths.map((item)=>String(item)) : [],
         decisionReplay: Array.isArray(artifact.decisionReplay) ? artifact.decisionReplay.map((item)=>String(item)) : [],
         reviewNotes: Array.isArray(artifact.reviewNotes) ? artifact.reviewNotes.map((note)=>({

package/dist/tui.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import readline from "node:readline";
 import process from "node:process";
-import { cycleReviewAssignee } from "./reviews.js";
+import { cycleReviewAssignee, reviewNoteMatchesFilters } from "./reviews.js";
 import { extractPromptPathHints, routeTask } from "./router.js";
 import { pingRpc, rpcAddReviewNote, rpcAddReviewReply, rpcEnqueueReviewFollowUp, readSnapshot, rpcEnqueueTask, rpcResolveApproval, rpcSetReviewNoteStatus, rpcShutdown, rpcTaskArtifact, rpcUpdateReviewNote, rpcWorktreeDiff, subscribeSnapshotRpc } from "./rpc.js";
 const RESET = "\u001b[0m";
@@ -569,6 +569,41 @@ function reviewAssigneeLabel(assignee) {
             return "unassigned";
     }
 }
+function reviewFilterLabel(filters) {
+    return `status=${filters.status} | assignee=${filters.assignee === "all" ? "all" : reviewAssigneeLabel(filters.assignee)} | disposition=${filters.disposition === "all" ? "all" : reviewDispositionLabel(filters.disposition)}`;
+}
+function cycleReviewFilterAssignee(current) {
+    const sequence = [
+        "all",
+        "codex",
+        "claude",
+        "operator"
+    ];
+    const index = sequence.findIndex((item)=>item === current);
+    return sequence[(index + 1) % sequence.length] ?? "all";
+}
+function cycleReviewFilterDisposition(current) {
+    const sequence = [
+        "all",
+        "approve",
+        "concern",
+        "question",
+        "note",
+        "accepted_risk",
+        "wont_fix"
+    ];
+    const index = sequence.findIndex((item)=>item === current);
+    return sequence[(index + 1) % sequence.length] ?? "all";
+}
+function cycleReviewFilterStatus(current) {
+    const sequence = [
+        "all",
+        "open",
+        "resolved"
+    ];
+    const index = sequence.findIndex((item)=>item === current);
+    return sequence[(index + 1) % sequence.length] ?? "all";
+}
 function activeReviewContext(snapshot, ui) {
     const agent = reviewAgentForUi(snapshot, ui);
     if (!agent) {
@@ -590,7 +625,7 @@ function activeReviewContext(snapshot, ui) {
         hunkHeader
     };
 }
-function reviewNotesForContext(snapshot, context) {
+function reviewNotesForContext(snapshot, context, filters) {
     if (!snapshot || !context) {
         return [];
     }
@@ -600,18 +635,25 @@ function reviewNotesForContext(snapshot, context) {
         if (note.agent !== context.agent || note.filePath !== context.filePath) {
             return false;
         }
-        if (context.hunkIndex !== null) {
-            return note.hunkIndex === context.hunkIndex || note.hunkIndex === null;
+        if (context.hunkIndex !== null && !(note.hunkIndex === context.hunkIndex || note.hunkIndex === null)) {
+            return false;
+        }
+        if (!reviewNoteMatchesFilters(note, {
+            assignee: filters.assignee === "all" ? null : filters.assignee,
+            disposition: filters.disposition === "all" ? null : filters.disposition,
+            status: filters.status === "all" ? null : filters.status
+        })) {
+            return false;
         }
         return true;
     }).sort((left, right)=>right.createdAt.localeCompare(left.createdAt));
 }
 function syncSelectedReviewNote(snapshot, ui) {
-    const notes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui));
+    const notes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui), ui.reviewFilters);
     ui.selectedReviewNoteId = notes.some((note)=>note.id === ui.selectedReviewNoteId) ? ui.selectedReviewNoteId : notes[0]?.id ?? null;
 }
 function selectedReviewNote(snapshot, ui) {
-    const notes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui));
+    const notes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui), ui.reviewFilters);
     return notes.find((note)=>note.id === ui.selectedReviewNoteId) ?? notes[0] ?? null;
 }
 function renderReviewNotesSection(notes, selectedNoteId, width) {
@@ -753,10 +795,13 @@ function renderTaskInspector(task, artifactEntry, loading, diffEntry, loadingDif
             `Owner: ${task.owner}`,
             `Status: ${task.status}`,
             `Updated: ${shortTime(task.updatedAt)}`,
-            `Route: ${task.routeReason ?? "-"}`,
+            `Route: ${task.routeStrategy ?? "-"}${task.routeConfidence === null ? "" : ` (${task.routeConfidence.toFixed(2)})`} ${task.routeReason ?? "-"}`,
             `Claimed paths: ${task.claimedPaths.join(", ") || "-"}`,
             `Summary: ${task.summary ?? "-"}`
         ].flatMap((line)=>wrapText(line, innerWidth))));
+        if (Object.keys(task.routeMetadata).length > 0) {
+            lines.push(...section("Route Metadata", wrapText(JSON.stringify(task.routeMetadata), innerWidth)));
+        }
         if (loading) {
             lines.push(...section("Artifact", [
                 "Loading task artifact..."
@@ -809,7 +854,7 @@ function renderTaskInspector(task, artifactEntry, loading, diffEntry, loadingDif
         lines.push(...section("Task Scope", [
             `Owner: ${task.owner}`,
             `Claimed paths: ${task.claimedPaths.join(", ") || "-"}`,
-            `Route reason: ${task.routeReason ?? "-"}`
+            `Route reason: ${task.routeStrategy ?? "-"}${task.routeConfidence === null ? "" : ` (${task.routeConfidence.toFixed(2)})`} ${task.routeReason ?? "-"}`
         ].flatMap((line)=>wrapText(line, innerWidth))));
         if (!agent) {
             lines.push(...section("Diff Review", [
@@ -826,7 +871,7 @@ function renderTaskInspector(task, artifactEntry, loading, diffEntry, loadingDif
             const hunks = parseDiffHunks(review.patch);
             const hunkIndex = agent ? selectedHunkIndex(ui, agent, review) : null;
             const selectedHunk = hunkIndex === null ? null : hunks[hunkIndex] ?? null;
-            const reviewNotes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui));
+            const reviewNotes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui), ui.reviewFilters);
             lines.push(...section("Review", [
                 `Agent: ${review.agent}`,
                 `Selected file: ${review.selectedPath ?? "-"}`,
@@ -834,6 +879,7 @@ function renderTaskInspector(task, artifactEntry, loading, diffEntry, loadingDif
                 `Hunks: ${hunks.length}`,
                 `Selected hunk: ${hunkIndex === null ? "-" : `${hunkIndex + 1}/${hunks.length}`}`,
                 `Notes: ${reviewNotes.length}`,
+                `Filters: ${reviewFilterLabel(ui.reviewFilters)}`,
                 `Stat: ${review.stat}`
             ].flatMap((line)=>wrapText(line, innerWidth))));
             lines.push(...section("Changed Files", review.changedPaths.length ? review.changedPaths.flatMap((filePath)=>wrapText(`${filePath === review.selectedPath ? ">" : "-"} ${filePath}`, innerWidth)) : [
@@ -1024,12 +1070,13 @@ function renderWorktreeInspector(snapshot, worktree, diffEntry, loadingDiff, ui,
         const hunks = parseDiffHunks(diffEntry.review.patch);
         const hunkIndex = selectedHunkIndex(ui, worktree.agent, diffEntry.review);
         const selectedHunk = hunkIndex === null ? null : hunks[hunkIndex] ?? null;
-        const reviewNotes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui));
+        const reviewNotes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui), ui.reviewFilters);
         lines.push(...section("Review", [
             `Selected file: ${diffEntry.review.selectedPath ?? "-"}`,
             `Hunks: ${hunks.length}`,
             `Selected hunk: ${hunkIndex === null ? "-" : `${hunkIndex + 1}/${hunks.length}`}`,
             `Notes: ${reviewNotes.length}`,
+            `Filters: ${reviewFilterLabel(ui.reviewFilters)}`,
             `Stat: ${diffEntry.review.stat}`
         ].flatMap((line)=>wrapText(line, innerWidth))));
         if (selectedHunk) {
@@ -1178,7 +1225,7 @@ function renderFooter(snapshot, ui, width) {
     }
     return [
         fitAnsiLine("Keys: 1-7 tabs | h/l or Tab cycle tabs | j/k move | [ ] task detail | ,/. diff file | { } diff hunk | c compose | r refresh", width),
-        fitAnsiLine("Actions: y/Y allow approval | n/N deny approval | A/C/Q/M add note | o/O select note | T reply | E edit | R resolve | a cycle assignee | w won't fix | x accepted risk | F fix task | H handoff | g/G top/bottom | s stop daemon | q quit", width),
+        fitAnsiLine("Actions: y/Y allow approval | n/N deny approval | A/C/Q/M add note | o/O select note | T reply | E edit | R resolve | a cycle assignee | u filter assignee | v filter status | d filter disposition | w won't fix | x accepted risk | F fix task | H handoff | g/G top/bottom | s stop daemon | q quit", width),
         footerSelectionSummary(snapshot, ui, width),
         fitAnsiLine(toast ? styleLine(toast.message, toast.level === "error" ? "bad" : "good") : styleLine("Operator surface is live over the daemon socket with pushed snapshots.", "muted"), width)
     ];
@@ -1311,12 +1358,17 @@ async function queueManualTask(paths, view, ui) {
         strategy: "manual",
         confidence: 1,
         reason: `Operator manually assigned the task to ${composer.owner}.`,
-        claimedPaths: extractPromptPathHints(prompt)
+        claimedPaths: extractPromptPathHints(prompt),
+        metadata: {
+            manualAssignment: true,
+            composerOwner: composer.owner
+        }
     };
     await rpcEnqueueTask(paths, {
         owner: routeDecision.owner,
         prompt,
         routeReason: routeDecision.reason,
+        routeMetadata: routeDecision.metadata,
         claimedPaths: routeDecision.claimedPaths,
         routeStrategy: routeDecision.strategy,
         routeConfidence: routeDecision.confidence
@@ -1425,7 +1477,7 @@ async function resolveSelectedReviewNoteWithDisposition(paths, snapshot, ui, dis
     setToast(ui, "info", `Marked review note ${note.id} as ${reviewDispositionLabel(disposition).toLowerCase()}.`);
 }
 function cycleSelectedReviewNote(snapshot, ui, delta) {
-    const notes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui));
+    const notes = reviewNotesForContext(snapshot, activeReviewContext(snapshot, ui), ui.reviewFilters);
     if (notes.length === 0) {
         ui.selectedReviewNoteId = null;
         return false;
@@ -1589,7 +1641,12 @@ export async function attachTui(paths) {
             codex: 0,
             claude: 0
         },
-        selectedReviewNoteId: null
+        selectedReviewNoteId: null,
+        reviewFilters: {
+            assignee: "all",
+            disposition: "all",
+            status: "all"
+        }
     };
     const render = ()=>{
         process.stdout.write(renderScreen(view, ui, paths));
@@ -1984,6 +2041,27 @@ export async function attachTui(paths) {
             });
             return;
         }
+        if (input === "u") {
+            ui.reviewFilters.assignee = cycleReviewFilterAssignee(ui.reviewFilters.assignee);
+            syncSelectedReviewNote(view.snapshot, ui);
+            setToast(ui, "info", `Review assignee filter: ${ui.reviewFilters.assignee === "all" ? "all" : reviewAssigneeLabel(ui.reviewFilters.assignee)}.`);
+            render();
+            return;
+        }
+        if (input === "v") {
+            ui.reviewFilters.status = cycleReviewFilterStatus(ui.reviewFilters.status);
+            syncSelectedReviewNote(view.snapshot, ui);
+            setToast(ui, "info", `Review status filter: ${ui.reviewFilters.status}.`);
+            render();
+            return;
+        }
+        if (input === "d") {
+            ui.reviewFilters.disposition = cycleReviewFilterDisposition(ui.reviewFilters.disposition);
+            syncSelectedReviewNote(view.snapshot, ui);
+            setToast(ui, "info", `Review disposition filter: ${ui.reviewFilters.disposition === "all" ? "all" : reviewDispositionLabel(ui.reviewFilters.disposition)}.`);
+            render();
+            return;
+        }
         if (input === "w" || input === "x") {
             runAction(async ()=>{
                 await resolveSelectedReviewNoteWithDisposition(paths, view.snapshot, ui, input === "w" ? "wont_fix" : "accepted_risk");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mandipadk7/kavi",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Managed Codex + Claude collaboration TUI",
   "type": "module",
   "preferGlobal": true,