@mandipadk7/kavi 0.1.5 → 0.1.6

package/README.md

@@ -11,6 +11,8 @@ Current capabilities:
 - `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, task counts, and configured routing ownership rules from any terminal.
+- `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 tasks`: inspect the session task list with summaries and artifact availability.
@@ -33,6 +35,7 @@ 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.
+- 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.
 
 Notes:
@@ -41,10 +44,12 @@ Notes:
 - 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.
+- `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.
+- 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.
 - 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.
 - 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/adapters/shared.js

@@ -4,11 +4,13 @@ function formatDecisionLine(summary, detail) {
     return detail.trim() ? `- ${summary}: ${detail}` : `- ${summary}`;
 }
 export function buildDecisionReplay(session, task, agent) {
+    const winningRule = task.routeMetadata?.winningRule && typeof task.routeMetadata.winningRule === "object" && !Array.isArray(task.routeMetadata.winningRule) && typeof task.routeMetadata.winningRule.pattern === "string" ? String(task.routeMetadata.winningRule.pattern) : null;
     const taskDecisions = session.decisions.filter((decision)=>decision.taskId === task.id).slice(-6).map((decision)=>formatDecisionLine(`[${decision.kind}] ${decision.summary}`, decision.detail));
     const sharedDecisions = session.decisions.filter((decision)=>decision.taskId !== task.id && (decision.agent === agent || decision.agent === null)).slice(-4).map((decision)=>formatDecisionLine(`[${decision.kind}] ${decision.summary}`, decision.detail));
     const relevantClaims = session.pathClaims.filter((claim)=>claim.status === "active" && (claim.taskId === task.id || claim.agent !== agent)).slice(-6).map((claim)=>`- ${claim.agent} ${claim.source} claim on ${claim.paths.join(", ")}${claim.note ? `: ${claim.note}` : ""}`);
     const replay = [
         `- Current route reason: ${task.routeReason ?? "not recorded"}`,
+        `- Winning ownership rule: ${winningRule ?? "none"}`,
         `- Current claimed paths: ${task.claimedPaths.join(", ") || "none"}`,
         ...taskDecisions,
         ...sharedDecisions,

package/dist/daemon.js

@@ -1002,7 +1002,10 @@ export class KaviDaemon {
             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");
+        const previousClaimedPaths = [
+            ...task.claimedPaths
+        ];
+        const hadClaimedSurface = previousClaimedPaths.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,
@@ -1031,6 +1034,14 @@ export class KaviDaemon {
                         supersededByPaths: changedPaths
                     }
                 });
+                await recordEvent(this.paths, this.session.id, "claim.superseded", {
+                    claimId: releasedClaim.id,
+                    taskId: releasedClaim.taskId,
+                    agent: releasedClaim.agent,
+                    paths: releasedClaim.paths,
+                    supersededByTaskId: task.id,
+                    supersededByPaths: changedPaths
+                });
             }
             return;
         }
@@ -1045,6 +1056,12 @@ export class KaviDaemon {
                     releaseReason: "empty-diff-claim"
                 }
             });
+            await recordEvent(this.paths, this.session.id, "claim.released", {
+                taskId: task.id,
+                agent: task.owner,
+                paths: previousClaimedPaths,
+                reason: "empty-diff-claim"
+            });
         }
     }
 }

package/dist/decision-ledger.js

@@ -21,6 +21,17 @@ function pathOverlaps(left, right) {
     }
     return leftPath === rightPath || leftPath.startsWith(`${rightPath}/`) || rightPath.startsWith(`${leftPath}/`);
 }
+function overlapPath(left, right) {
+    const leftPath = normalizePath(left);
+    const rightPath = normalizePath(right);
+    if (!pathOverlaps(leftPath, rightPath)) {
+        return null;
+    }
+    if (leftPath === rightPath) {
+        return leftPath;
+    }
+    return leftPath.startsWith(`${rightPath}/`) ? leftPath : rightPath;
+}
 export function addDecisionRecord(session, input) {
     const record = {
         id: randomUUID(),
@@ -126,6 +137,85 @@ export function findClaimConflicts(session, owner, claimedPaths) {
     }
     return activePathClaims(session).filter((claim)=>claim.agent !== owner && claim.paths.some((item)=>normalizedPaths.some((candidate)=>pathOverlaps(item, candidate))));
 }
+export function buildClaimHotspots(session) {
+    const hotspots = new Map();
+    const claims = activePathClaims(session);
+    for(let index = 0; index < claims.length; index += 1){
+        const left = claims[index];
+        if (!left) {
+            continue;
+        }
+        for(let inner = index + 1; inner < claims.length; inner += 1){
+            const right = claims[inner];
+            if (!right || left.taskId === right.taskId) {
+                continue;
+            }
+            const overlappingPaths = left.paths.flatMap((leftPath)=>right.paths.map((rightPath)=>overlapPath(leftPath, rightPath)).filter((value)=>Boolean(value)));
+            if (overlappingPaths.length === 0) {
+                continue;
+            }
+            for (const hotspotPath of overlappingPaths){
+                const existing = hotspots.get(hotspotPath);
+                if (existing) {
+                    existing.overlapCount += 1;
+                    existing.agents = [
+                        ...new Set([
+                            ...existing.agents,
+                            left.agent,
+                            right.agent
+                        ])
+                    ];
+                    existing.taskIds = [
+                        ...new Set([
+                            ...existing.taskIds,
+                            left.taskId,
+                            right.taskId
+                        ])
+                    ];
+                    existing.claimIds = [
+                        ...new Set([
+                            ...existing.claimIds,
+                            left.id,
+                            right.id
+                        ])
+                    ];
+                    continue;
+                }
+                hotspots.set(hotspotPath, {
+                    path: hotspotPath,
+                    agents: [
+                        ...new Set([
+                            left.agent,
+                            right.agent
+                        ])
+                    ],
+                    taskIds: [
+                        ...new Set([
+                            left.taskId,
+                            right.taskId
+                        ])
+                    ],
+                    claimIds: [
+                        ...new Set([
+                            left.id,
+                            right.id
+                        ])
+                    ],
+                    overlapCount: 1
+                });
+            }
+        }
+    }
+    return [
+        ...hotspots.values()
+    ].sort((left, right)=>{
+        const overlapDelta = right.overlapCount - left.overlapCount;
+        if (overlapDelta !== 0) {
+            return overlapDelta;
+        }
+        return left.path.localeCompare(right.path);
+    });
+}
 
 
 //# sourceURL=decision-ledger.ts

package/dist/doctor.js

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { loadConfig } from "./config.js";
 import { fileExists } from "./fs.js";
+import { findOwnershipRuleConflicts } from "./ownership.js";
 import { runCommand } from "./process.js";
 import { hasSupportedNode, minimumNodeMajor, resolveSessionRuntime } from "./runtime.js";
 export function parseClaudeAuthStatus(output) {
@@ -87,6 +88,10 @@ export function validateRoutingPathRules(config) {
             ...new Set(overlappingRules)
         ].join(", ")}`);
     }
+    const ambiguousConflicts = findOwnershipRuleConflicts(config).filter((conflict)=>conflict.kind === "ambiguous-overlap").map((conflict)=>`${conflict.leftOwner}:${conflict.leftPattern} <> ${conflict.rightOwner}:${conflict.rightPattern}`);
+    if (ambiguousConflicts.length > 0) {
+        issues.push(`Ownership rules have ambiguous overlaps without a specificity winner: ${ambiguousConflicts.join(", ")}`);
+    }
     return issues;
 }
 function normalizeVersion(output) {

package/dist/main.js

@@ -6,16 +6,17 @@ 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, releasePathClaims, upsertPathClaim } from "./decision-ledger.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 { 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 { findOwnershipRuleConflicts } from "./ownership.js";
 import { filterReviewNotes, markReviewNotesLandedForTasks } from "./reviews.js";
 import { resolveSessionRuntime } from "./runtime.js";
-import { buildAdHocTask, extractPromptPathHints, routeTask } from "./router.js";
+import { buildAdHocTask, extractPromptPathHints, previewRouteDecision, routeTask } from "./router.js";
 import { createSessionRecord, loadSessionRecord, readRecentEvents, recordEvent, saveSessionRecord, sessionExists, sessionHeartbeatAgeMs } from "./session.js";
 import { listTaskArtifacts, loadTaskArtifact, saveTaskArtifact } from "./task-artifacts.js";
 import { attachTui } from "./tui.js";
@@ -73,6 +74,8 @@ function renderUsage() {
         "  kavi open [--goal \"...\"]",
         "  kavi resume",
         "  kavi status [--json]",
+        "  kavi route [--json] [--no-ai] <prompt>",
+        "  kavi routes [--json] [--limit N]",
         "  kavi paths [--json]",
         "  kavi task [--agent codex|claude|auto] <prompt>",
         "  kavi tasks [--json]",
@@ -291,6 +294,25 @@ async function notifyOperatorSurface(paths, reason) {
         await rpcNotifyExternalUpdate(paths, reason);
     } catch  {}
 }
+function buildRouteAnalytics(tasks) {
+    const byOwner = {
+        codex: 0,
+        claude: 0
+    };
+    const byStrategy = {};
+    for (const task of tasks){
+        if (task.owner === "codex" || task.owner === "claude") {
+            byOwner[task.owner] += 1;
+        }
+        if (task.routeStrategy) {
+            byStrategy[task.routeStrategy] = (byStrategy[task.routeStrategy] ?? 0) + 1;
+        }
+    }
+    return {
+        byOwner,
+        byStrategy
+    };
+}
 async function commandOpen(cwd, args) {
     const goal = getGoal(args);
     await startOrAttachSession(cwd, goal);
@@ -323,6 +345,9 @@ async function commandStatus(cwd, args) {
     const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
     const pendingApprovals = rpcSnapshot?.approvals.filter((item)=>item.status === "pending") ?? await listApprovalRequests(paths);
     const heartbeatAgeMs = sessionHeartbeatAgeMs(session);
+    const routeAnalytics = buildRouteAnalytics(session.tasks);
+    const ownershipConflicts = findOwnershipRuleConflicts(session.config);
+    const claimHotspots = buildClaimHotspots(session);
     const payload = {
         id: session.id,
         status: session.status,
@@ -356,6 +381,9 @@ async function commandStatus(cwd, args) {
         pathClaimCounts: {
             active: session.pathClaims.filter((claim)=>claim.status === "active").length
         },
+        routeCounts: routeAnalytics,
+        ownershipConflicts: ownershipConflicts.length,
+        claimHotspots: claimHotspots.length,
         routingOwnership: {
             codexPaths: session.config.routing.codexPaths,
             claudePaths: session.config.routing.claudePaths
@@ -379,11 +407,83 @@ 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(`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(", ") || "-"}`);
     for (const worktree of payload.worktrees){
         console.log(`- ${worktree.agent}: ${worktree.path}`);
     }
 }
+async function commandRoute(cwd, args) {
+    const prompt = getGoal(args);
+    if (!prompt) {
+        throw new Error("A route preview prompt is required. Example: kavi route \"Refactor src/ui/App.tsx\"");
+    }
+    const repoRoot = await findRepoRoot(cwd) ?? cwd;
+    const paths = resolveAppPaths(repoRoot);
+    const allowAi = !args.includes("--no-ai");
+    const hasSession = await sessionExists(paths);
+    const session = hasSession ? await loadSessionRecord(paths) : null;
+    const config = session?.config ?? await loadConfig(paths);
+    const routeDecision = allowAi && session ? await routeTask(prompt, session, paths) : previewRouteDecision(prompt, config, session);
+    const payload = {
+        prompt,
+        mode: allowAi && session ? "live" : "preview",
+        route: routeDecision
+    };
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    console.log(`Mode: ${payload.mode}`);
+    console.log(`Owner: ${routeDecision.owner}`);
+    console.log(`Strategy: ${routeDecision.strategy}`);
+    console.log(`Confidence: ${routeDecision.confidence.toFixed(2)}`);
+    console.log(`Reason: ${routeDecision.reason}`);
+    console.log(`Claimed paths: ${routeDecision.claimedPaths.join(", ") || "-"}`);
+    if (Object.keys(routeDecision.metadata).length > 0) {
+        console.log(`Metadata: ${JSON.stringify(routeDecision.metadata)}`);
+    }
+}
+async function commandRoutes(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
+    const limitArg = getFlag(args, "--limit");
+    const limit = limitArg ? Number(limitArg) : 20;
+    const routes = [
+        ...session.tasks
+    ].filter((task)=>task.routeStrategy !== null).sort((left, right)=>right.updatedAt.localeCompare(left.updatedAt)).slice(0, Math.max(1, Number.isFinite(limit) ? limit : 20)).map((task)=>({
+            taskId: task.id,
+            title: task.title,
+            owner: task.owner,
+            status: task.status,
+            updatedAt: task.updatedAt,
+            routeStrategy: task.routeStrategy,
+            routeConfidence: task.routeConfidence,
+            routeReason: task.routeReason,
+            routeMetadata: task.routeMetadata,
+            claimedPaths: task.claimedPaths
+        }));
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(routes, null, 2));
+        return;
+    }
+    if (routes.length === 0) {
+        console.log("No routed tasks recorded.");
+        return;
+    }
+    for (const route of routes){
+        console.log(`${route.taskId} | ${route.owner} | ${route.status} | ${route.routeStrategy ?? "-"}${route.routeConfidence === null ? "" : ` (${route.routeConfidence.toFixed(2)})`}`);
+        console.log(`  title: ${route.title}`);
+        console.log(`  updated: ${route.updatedAt}`);
+        console.log(`  reason: ${route.routeReason ?? "-"}`);
+        console.log(`  paths: ${route.claimedPaths.join(", ") || "-"}`);
+        if (Object.keys(route.routeMetadata).length > 0) {
+            console.log(`  metadata: ${JSON.stringify(route.routeMetadata)}`);
+        }
+    }
+}
 async function commandPaths(cwd, args) {
     const repoRoot = await findRepoRoot(cwd) ?? cwd;
     const paths = resolveAppPaths(repoRoot);
@@ -843,6 +943,14 @@ async function commandLand(cwd) {
                 releaseReason: "land.completed"
             }
         });
+        await recordEvent(paths, session.id, "claim.released", {
+            claimId: claim.id,
+            taskId: claim.taskId,
+            agent: claim.agent,
+            paths: claim.paths,
+            reason: "land.completed",
+            targetBranch
+        });
     }
     const landedReviewNotes = markReviewNotesLandedForTasks(session, session.tasks.filter((task)=>task.status === "completed").map((task)=>task.id));
     for (const note of landedReviewNotes){
@@ -1028,6 +1136,12 @@ async function main() {
         case "status":
             await commandStatus(cwd, args);
             break;
+        case "route":
+            await commandRoute(cwd, args);
+            break;
+        case "routes":
+            await commandRoutes(cwd, args);
+            break;
         case "paths":
             await commandPaths(cwd, args);
             break;

package/dist/ownership.js

@@ -0,0 +1,276 @@
+import path from "node:path";
+export function normalizeOwnershipPattern(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 globToRegex(pattern) {
+    const normalized = normalizeOwnershipPattern(pattern);
+    const escaped = normalized.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    const regexSource = escaped.replaceAll("**", "::double-star::").replaceAll("*", "[^/]*").replaceAll("::double-star::", ".*");
+    return new RegExp(`^${regexSource}$`);
+}
+export function matchesOwnershipPattern(filePath, pattern) {
+    const normalizedPath = normalizeOwnershipPattern(filePath);
+    const normalizedPattern = normalizeOwnershipPattern(pattern);
+    if (!normalizedPath || !normalizedPattern) {
+        return false;
+    }
+    return globToRegex(normalizedPattern).test(normalizedPath);
+}
+function ownershipStaticPrefix(pattern) {
+    const normalized = normalizeOwnershipPattern(pattern);
+    const wildcardIndex = normalized.indexOf("*");
+    const prefix = wildcardIndex === -1 ? normalized : normalized.slice(0, wildcardIndex);
+    return prefix.replace(/\/+$/, "");
+}
+function wildcardCount(pattern) {
+    return (pattern.match(/\*/g) ?? []).length;
+}
+function literalLength(pattern) {
+    return pattern.replaceAll("*", "").length;
+}
+function segmentCount(pattern) {
+    return pattern.split("/").filter(Boolean).length;
+}
+function exactCoverage(pattern, matchedPaths) {
+    const normalizedPattern = normalizeOwnershipPattern(pattern);
+    if (normalizedPattern.includes("*")) {
+        return 0;
+    }
+    return matchedPaths.filter((filePath)=>normalizeOwnershipPattern(filePath) === normalizedPattern).length;
+}
+function buildOwnershipRuleCandidate(owner, pattern, declaredIndex, claimedPaths) {
+    const normalizedPattern = normalizeOwnershipPattern(pattern);
+    if (!normalizedPattern) {
+        return null;
+    }
+    const matchedPaths = claimedPaths.filter((filePath)=>matchesOwnershipPattern(filePath, normalizedPattern));
+    if (matchedPaths.length === 0) {
+        return null;
+    }
+    return {
+        owner,
+        pattern,
+        normalizedPattern,
+        declaredIndex,
+        matchedPaths,
+        coverage: matchedPaths.length,
+        exactCoverage: exactCoverage(normalizedPattern, matchedPaths),
+        staticPrefixLength: ownershipStaticPrefix(normalizedPattern).length,
+        literalLength: literalLength(normalizedPattern),
+        segmentCount: segmentCount(normalizedPattern),
+        wildcardCount: wildcardCount(normalizedPattern)
+    };
+}
+function compareRulePriority(left, right) {
+    const comparisons = [
+        [
+            left.coverage,
+            right.coverage,
+            false
+        ],
+        [
+            left.exactCoverage,
+            right.exactCoverage,
+            false
+        ],
+        [
+            left.staticPrefixLength,
+            right.staticPrefixLength,
+            false
+        ],
+        [
+            left.literalLength,
+            right.literalLength,
+            false
+        ],
+        [
+            left.segmentCount,
+            right.segmentCount,
+            false
+        ],
+        [
+            left.wildcardCount,
+            right.wildcardCount,
+            true
+        ]
+    ];
+    for (const [leftValue, rightValue, preferLower] of comparisons){
+        if (leftValue === rightValue) {
+            continue;
+        }
+        if (preferLower) {
+            return leftValue < rightValue ? 1 : -1;
+        }
+        return leftValue > rightValue ? 1 : -1;
+    }
+    return 0;
+}
+function compareRuleCandidates(left, right) {
+    const priority = compareRulePriority(left, right);
+    if (priority !== 0) {
+        return priority;
+    }
+    if (left.owner === right.owner && left.declaredIndex !== right.declaredIndex) {
+        return left.declaredIndex < right.declaredIndex ? 1 : -1;
+    }
+    return 0;
+}
+function pathAncestorsOverlap(left, right) {
+    return left === right || left.startsWith(`${right}/`) || right.startsWith(`${left}/`);
+}
+function patternsMayOverlap(leftPattern, rightPattern) {
+    const left = normalizeOwnershipPattern(leftPattern);
+    const right = normalizeOwnershipPattern(rightPattern);
+    if (!left || !right) {
+        return false;
+    }
+    if (left === right) {
+        return true;
+    }
+    const leftPrefix = ownershipStaticPrefix(left);
+    const rightPrefix = ownershipStaticPrefix(right);
+    if (!leftPrefix || !rightPrefix) {
+        return false;
+    }
+    return pathAncestorsOverlap(leftPrefix, rightPrefix);
+}
+function summarizeCandidate(candidate) {
+    return {
+        owner: candidate.owner,
+        pattern: candidate.pattern,
+        declaredIndex: candidate.declaredIndex,
+        matchedPaths: candidate.matchedPaths,
+        coverage: candidate.coverage,
+        exactCoverage: candidate.exactCoverage,
+        staticPrefixLength: candidate.staticPrefixLength,
+        literalLength: candidate.literalLength,
+        segmentCount: candidate.segmentCount,
+        wildcardCount: candidate.wildcardCount
+    };
+}
+export function analyzeOwnershipRules(claimedPaths, config) {
+    const candidates = [
+        ...config.routing.codexPaths.map((pattern, index)=>buildOwnershipRuleCandidate("codex", pattern, index, claimedPaths)).filter((candidate)=>candidate !== null),
+        ...config.routing.claudePaths.map((pattern, index)=>buildOwnershipRuleCandidate("claude", pattern, index, claimedPaths)).filter((candidate)=>candidate !== null)
+    ].sort((left, right)=>compareRuleCandidates(right, left));
+    const winningCandidate = candidates[0] ?? null;
+    if (!winningCandidate) {
+        return {
+            claimedPaths,
+            candidates,
+            winningCandidate: null,
+            ambiguousCandidates: []
+        };
+    }
+    const ambiguousCandidates = candidates.filter((candidate)=>candidate.owner !== winningCandidate.owner && compareRulePriority(candidate, winningCandidate) === 0);
+    return {
+        claimedPaths,
+        candidates,
+        winningCandidate: ambiguousCandidates.length > 0 ? null : winningCandidate,
+        ambiguousCandidates
+    };
+}
+export function ownershipMetadataFromAnalysis(analysis) {
+    const metadata = {};
+    if (analysis.winningCandidate) {
+        metadata.winningRule = summarizeCandidate(analysis.winningCandidate);
+        metadata.matchedRules = analysis.candidates.slice(0, 4).map(summarizeCandidate);
+    }
+    if (analysis.ambiguousCandidates.length > 0 && analysis.candidates[0]) {
+        metadata.ownershipAmbiguity = {
+            claimedPaths: analysis.claimedPaths,
+            contenders: [
+                analysis.candidates[0],
+                ...analysis.ambiguousCandidates
+            ].map(summarizeCandidate)
+        };
+    }
+    return metadata;
+}
+export function buildOwnershipRouteDecision(claimedPaths, config) {
+    const analysis = analyzeOwnershipRules(claimedPaths, config);
+    if (!analysis.winningCandidate) {
+        return null;
+    }
+    const candidate = analysis.winningCandidate;
+    return {
+        owner: candidate.owner,
+        strategy: "manual",
+        confidence: 0.97,
+        reason: `Matched explicit ${candidate.owner} ownership rule ${candidate.pattern} for: ${candidate.matchedPaths.join(", ")}.`,
+        claimedPaths,
+        metadata: {
+            ownershipSource: "config-routing-paths",
+            ...ownershipMetadataFromAnalysis(analysis)
+        }
+    };
+}
+export function findOwnershipRuleConflicts(config) {
+    const conflicts = [];
+    const leftRules = config.routing.codexPaths.map((pattern, index)=>({
+            owner: "codex",
+            pattern,
+            normalizedPattern: normalizeOwnershipPattern(pattern),
+            declaredIndex: index
+        }));
+    const rightRules = config.routing.claudePaths.map((pattern, index)=>({
+            owner: "claude",
+            pattern,
+            normalizedPattern: normalizeOwnershipPattern(pattern),
+            declaredIndex: index
+        }));
+    for (const left of leftRules){
+        if (!left.normalizedPattern) {
+            continue;
+        }
+        for (const right of rightRules){
+            if (!right.normalizedPattern || !patternsMayOverlap(left.pattern, right.pattern)) {
+                continue;
+            }
+            if (left.normalizedPattern === right.normalizedPattern) {
+                conflicts.push({
+                    leftOwner: left.owner,
+                    leftPattern: left.pattern,
+                    rightOwner: right.owner,
+                    rightPattern: right.pattern,
+                    kind: "exact",
+                    detail: `Both agents claim the same ownership rule ${left.pattern}.`
+                });
+                continue;
+            }
+            const syntheticPath = [
+                ownershipStaticPrefix(left.normalizedPattern),
+                ownershipStaticPrefix(right.normalizedPattern)
+            ].filter(Boolean).sort((a, b)=>b.length - a.length)[0];
+            if (!syntheticPath) {
+                continue;
+            }
+            const leftCandidate = buildOwnershipRuleCandidate(left.owner, left.pattern, left.declaredIndex, [
+                syntheticPath
+            ]);
+            const rightCandidate = buildOwnershipRuleCandidate(right.owner, right.pattern, right.declaredIndex, [
+                syntheticPath
+            ]);
+            if (!leftCandidate || !rightCandidate) {
+                continue;
+            }
+            if (compareRulePriority(leftCandidate, rightCandidate) === 0) {
+                conflicts.push({
+                    leftOwner: left.owner,
+                    leftPattern: left.pattern,
+                    rightOwner: right.owner,
+                    rightPattern: right.pattern,
+                    kind: "ambiguous-overlap",
+                    detail: `Ownership rules ${left.pattern} and ${right.pattern} can overlap without a specificity winner.`
+                });
+            }
+        }
+    }
+    return conflicts;
+}
+
+
+//# sourceURL=ownership.ts

package/dist/router.js

@@ -1,6 +1,6 @@
-import path from "node:path";
 import { CodexAppServerClient } from "./codex-app-server.js";
 import { findClaimConflicts } from "./decision-ledger.js";
+import { analyzeOwnershipRules, buildOwnershipRouteDecision, ownershipMetadataFromAnalysis } from "./ownership.js";
 import { nowIso } from "./paths.js";
 const ROUTER_OUTPUT_SCHEMA = {
     type: "object",
@@ -47,61 +47,19 @@ function normalizeClaimedPaths(paths) {
 function buildRouteMetadata(input = {}) {
     return input;
 }
-function normalizePathPattern(value) {
-    const trimmed = value.trim().replaceAll("\\", "/");
-    const withoutPrefix = trimmed.startsWith("./") ? trimmed.slice(2) : trimmed;
-    const normalized = path.posix.normalize(withoutPrefix);
-    return normalized === "." ? "" : normalized.replace(/^\/+/, "");
-}
-function globToRegex(pattern) {
-    const normalized = normalizePathPattern(pattern);
-    const escaped = normalized.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
-    const regexSource = escaped.replaceAll("**", "::double-star::").replaceAll("*", "[^/]*").replaceAll("::double-star::", ".*");
-    return new RegExp(`^${regexSource}$`);
-}
-function matchesPattern(filePath, pattern) {
-    const normalizedPath = normalizePathPattern(filePath);
-    const normalizedPattern = normalizePathPattern(pattern);
-    if (!normalizedPath || !normalizedPattern) {
-        return false;
-    }
-    return globToRegex(normalizedPattern).test(normalizedPath);
-}
-function countPathMatches(filePaths, patterns) {
-    if (filePaths.length === 0 || patterns.length === 0) {
-        return 0;
+function ownershipAnalysisMetadata(prompt, config) {
+    const claimedPaths = extractPromptPathHints(prompt);
+    if (claimedPaths.length === 0) {
+        return {};
     }
-    return filePaths.filter((filePath)=>patterns.some((pattern)=>matchesPattern(filePath, pattern))).length;
+    return ownershipMetadataFromAnalysis(analyzeOwnershipRules(claimedPaths, config));
 }
 function buildPathOwnershipDecision(prompt, config) {
     const claimedPaths = extractPromptPathHints(prompt);
     if (claimedPaths.length === 0) {
         return null;
     }
-    const codexMatches = countPathMatches(claimedPaths, config.routing.codexPaths);
-    const claudeMatches = countPathMatches(claimedPaths, config.routing.claudePaths);
-    if (codexMatches === 0 && claudeMatches === 0) {
-        return null;
-    }
-    if (codexMatches === claudeMatches) {
-        return null;
-    }
-    const owner = codexMatches > claudeMatches ? "codex" : "claude";
-    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,
-        metadata: buildRouteMetadata({
-            ownershipSource: "config-routing-paths",
-            matchedPatterns,
-            codexMatches,
-            claudeMatches
-        })
-    };
+    return buildOwnershipRouteDecision(claimedPaths, config);
 }
 export function extractPromptPathHints(prompt) {
     const candidates = [];
@@ -131,10 +89,36 @@ export function routePrompt(prompt, config) {
     }
     return "codex";
 }
+export function previewRouteDecision(prompt, config, session = null) {
+    const pathDecision = buildPathOwnershipDecision(prompt, config);
+    if (pathDecision) {
+        return session ? applyClaimRouting(session, pathDecision) : pathDecision;
+    }
+    const heuristic = buildKeywordDecision(prompt, config);
+    if (heuristic) {
+        return session ? applyClaimRouting(session, heuristic) : heuristic;
+    }
+    const claimedPaths = extractPromptPathHints(prompt);
+    const previewDecision = {
+        owner: "codex",
+        strategy: "fallback",
+        confidence: 0.35,
+        reason: "No deterministic ownership or keyword route matched yet. The AI router would decide on submit.",
+        claimedPaths,
+        metadata: buildRouteMetadata({
+            router: "preview",
+            promptHints: claimedPaths,
+            aiPending: true,
+            ...ownershipAnalysisMetadata(prompt, config)
+        })
+    };
+    return session ? applyClaimRouting(session, previewDecision) : previewDecision;
+}
 function buildKeywordDecision(prompt, config) {
     const frontend = containsKeyword(prompt, config.routing.frontendKeywords);
     const backend = containsKeyword(prompt, config.routing.backendKeywords);
     const claimedPaths = extractPromptPathHints(prompt);
+    const ownershipMetadata = ownershipAnalysisMetadata(prompt, config);
     if (frontend && !backend) {
         return {
             owner: "claude",
@@ -144,7 +128,8 @@ function buildKeywordDecision(prompt, config) {
             claimedPaths,
             metadata: buildRouteMetadata({
                 matchedKeywordSet: "frontend",
-                promptHints: claimedPaths
+                promptHints: claimedPaths,
+                ...ownershipMetadata
             })
         };
     }
@@ -157,7 +142,8 @@ function buildKeywordDecision(prompt, config) {
             claimedPaths,
             metadata: buildRouteMetadata({
                 matchedKeywordSet: "backend",
-                promptHints: claimedPaths
+                promptHints: claimedPaths,
+                ...ownershipMetadata
             })
         };
     }
@@ -235,7 +221,8 @@ async function routeWithCodexAi(prompt, session) {
             claimedPaths,
             metadata: buildRouteMetadata({
                 router: "codex-ai",
-                promptHints: extractPromptPathHints(prompt)
+                promptHints: extractPromptPathHints(prompt),
+                ...ownershipAnalysisMetadata(prompt, session.config)
             })
         };
     } finally{
@@ -292,7 +279,8 @@ export async function routeTask(prompt, session, _paths) {
             claimedPaths: extractPromptPathHints(prompt),
             metadata: buildRouteMetadata({
                 router: "fallback",
-                error: error instanceof Error ? error.message : String(error)
+                error: error instanceof Error ? error.message : String(error),
+                ...ownershipAnalysisMetadata(prompt, session.config)
             })
         });
     }

package/dist/tui.js

@@ -1,8 +1,10 @@
 import path from "node:path";
 import readline from "node:readline";
 import process from "node:process";
+import { buildClaimHotspots } from "./decision-ledger.js";
+import { findOwnershipRuleConflicts } from "./ownership.js";
 import { cycleReviewAssignee, reviewNoteMatchesFilters } from "./reviews.js";
-import { extractPromptPathHints, routeTask } from "./router.js";
+import { extractPromptPathHints, previewRouteDecision, 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";
 const ANSI_PATTERN = /\u001b\[[0-9;]*m/g;
@@ -648,6 +650,26 @@ function reviewNotesForContext(snapshot, context, filters) {
         return true;
     }).sort((left, right)=>right.createdAt.localeCompare(left.createdAt));
 }
+function composerRoutePreview(snapshot, composer) {
+    if (!snapshot) {
+        return null;
+    }
+    const prompt = composer.prompt.trim();
+    if (!prompt) {
+        return null;
+    }
+    return composer.owner === "auto" ? previewRouteDecision(prompt, snapshot.session.config, snapshot.session) : {
+        owner: composer.owner,
+        strategy: "manual",
+        confidence: 1,
+        reason: `Operator manually assigned the task to ${composer.owner}.`,
+        claimedPaths: extractPromptPathHints(prompt),
+        metadata: {
+            manualAssignment: true,
+            composerOwner: composer.owner
+        }
+    };
+}
 function syncSelectedReviewNote(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;
@@ -943,15 +965,13 @@ function renderApprovalInspector(approval, width, height) {
         focused: true
     });
 }
-function renderClaimInspector(claim, width, height) {
-    if (!claim) {
-        return renderPanel("Inspector | Claim", width, height, [
-            styleLine("No claim selected.", "muted")
-        ]);
-    }
+function renderClaimInspector(snapshot, claim, width, height) {
     const innerWidth = Math.max(16, width - 2);
-    const lines = [
-        ...section("Claim", [
+    const hotspots = snapshot ? buildClaimHotspots(snapshot.session) : [];
+    const ownershipConflicts = snapshot ? findOwnershipRuleConflicts(snapshot.session.config) : [];
+    const lines = [];
+    if (claim) {
+        lines.push(...section("Claim", [
             `Id: ${claim.id}`,
             `Task: ${claim.taskId}`,
             `Agent: ${claim.agent}`,
@@ -960,11 +980,19 @@ function renderClaimInspector(claim, width, height) {
             `Created: ${shortTime(claim.createdAt)}`,
             `Updated: ${shortTime(claim.updatedAt)}`,
             `Note: ${claim.note ?? "-"}`
-        ].flatMap((line)=>wrapText(line, innerWidth))),
-        ...section("Paths", claim.paths.length > 0 ? claim.paths.flatMap((filePath)=>wrapText(`- ${filePath}`, innerWidth)) : [
+        ].flatMap((line)=>wrapText(line, innerWidth))), ...section("Paths", claim.paths.length > 0 ? claim.paths.flatMap((filePath)=>wrapText(`- ${filePath}`, innerWidth)) : [
             "- none"
-        ])
-    ];
+        ]));
+    } else {
+        lines.push(...section("Claim", [
+            "No claim selected."
+        ]));
+    }
+    lines.push(...section("Hotspots", hotspots.length > 0 ? hotspots.slice(0, 6).flatMap((hotspot)=>wrapText(`- ${hotspot.path} | agents=${hotspot.agents.join(", ")} | tasks=${hotspot.taskIds.length} | overlaps=${hotspot.overlapCount}`, innerWidth)) : [
+        "- none"
+    ]), ...section("Ownership Conflicts", ownershipConflicts.length > 0 ? ownershipConflicts.slice(0, 6).flatMap((conflict)=>wrapText(`- [${conflict.kind}] ${conflict.leftOwner}:${conflict.leftPattern} <> ${conflict.rightOwner}:${conflict.rightPattern}`, innerWidth)) : [
+        "- none"
+    ]));
     return renderPanel("Inspector | Claim", width, height, lines, {
         focused: true
     });
@@ -1108,7 +1136,7 @@ function renderInspector(snapshot, ui, width, height) {
         case "approvals":
             return renderApprovalInspector(selectedApproval(snapshot, ui), width, height);
         case "claims":
-            return renderClaimInspector(selectedClaim(snapshot, ui), width, height);
+            return renderClaimInspector(snapshot, selectedClaim(snapshot, ui), width, height);
         case "decisions":
             return renderDecisionInspector(selectedDecision(snapshot, ui), width, height);
         case "events":
@@ -1170,7 +1198,7 @@ function renderHeader(view, ui, width) {
     const repoName = path.basename(session?.repoRoot ?? process.cwd());
     const line1 = fitAnsiLine(`${toneForPanel("Kavi Operator", true)} | session=${session?.id ?? "-"} | repo=${repoName} | rpc=${view.connected ? "connected" : "disconnected"}`, width);
     const line2 = fitAnsiLine(`Goal: ${session?.goal ?? "-"} | status=${session?.status ?? "-"} | refresh=${shortTime(view.refreshedAt)}`, width);
-    const line3 = fitAnsiLine(session ? `Tasks P:${countTasks(session.tasks, "pending")} R:${countTasks(session.tasks, "running")} B:${countTasks(session.tasks, "blocked")} C:${countTasks(session.tasks, "completed")} F:${countTasks(session.tasks, "failed")} | approvals=${snapshot?.approvals.filter((approval)=>approval.status === "pending").length ?? 0} | reviews=${countOpenReviewNotes(snapshot)} | claims=${session.pathClaims.filter((claim)=>claim.status === "active").length} | decisions=${session.decisions.length}` : "Waiting for session snapshot...", width);
+    const line3 = fitAnsiLine(session ? `Tasks P:${countTasks(session.tasks, "pending")} R:${countTasks(session.tasks, "running")} B:${countTasks(session.tasks, "blocked")} C:${countTasks(session.tasks, "completed")} F:${countTasks(session.tasks, "failed")} | approvals=${snapshot?.approvals.filter((approval)=>approval.status === "pending").length ?? 0} | reviews=${countOpenReviewNotes(snapshot)} | claims=${session.pathClaims.filter((claim)=>claim.status === "active").length} | hotspots=${buildClaimHotspots(session).length} | ownership-conflicts=${findOwnershipRuleConflicts(session.config).length}` : "Waiting for session snapshot...", width);
     const tabs = OPERATOR_TABS.map((tab, index)=>{
         const count = buildTabItems(snapshot, tab).length;
         const label = `[${index + 1}] ${tabLabel(tab)} ${count}`;
@@ -1213,12 +1241,19 @@ function renderFooter(snapshot, ui, width) {
         ];
     }
     if (ui.composer) {
+        const preview = composerRoutePreview(snapshot, ui.composer);
+        const previewMetadata = preview && preview.metadata && typeof preview.metadata === "object" ? preview.metadata : {};
+        const winningRule = previewMetadata.winningRule && typeof previewMetadata.winningRule === "object" ? previewMetadata.winningRule : null;
         const composerHeader = fitAnsiLine(styleLine("Compose Task", "accent", "strong"), width);
         const composerLine = fitAnsiLine(`Route: ${ui.composer.owner} | 1 auto 2 codex 3 claude | Enter submit | Esc cancel | Ctrl+U clear`, width);
+        const previewLine = fitAnsiLine(preview ? `Preview: ${preview.owner} via ${preview.strategy} (${preview.confidence.toFixed(2)}) | ${preview.reason}` : "Preview: waiting for prompt", width);
+        const diagnosticsLine = fitAnsiLine(preview ? `Hints: ${preview.claimedPaths.join(", ") || "-"} | rule=${typeof winningRule?.pattern === "string" ? winningRule.pattern : "-"}` : "Hints: -", width);
         const promptLine = fitAnsiLine(`> ${ui.composer.prompt}`, width);
         return [
             composerHeader,
             composerLine,
+            previewLine,
+            diagnosticsLine,
             promptLine,
             fitAnsiLine(toast ? styleLine(toast.message, toast.level === "error" ? "bad" : "good") : styleLine("Composer accepts free text; tasks are routed or assigned when you press Enter.", "muted"), width)
         ];

package/package.json

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