@mandipadk7/kavi 0.1.4 → 0.1.6

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, 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 { markReviewNotesLandedForTasks } from "./reviews.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";
@@ -46,6 +47,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 "";
@@ -66,13 +74,15 @@ 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]",
         "  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]",
@@ -284,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);
@@ -316,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,
@@ -349,6 +381,13 @@ 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
+        },
         worktrees: session.worktrees
     };
     if (args.includes("--json")) {
@@ -368,10 +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);
@@ -429,13 +541,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 +562,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 +573,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 +596,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 +610,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 +654,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 +703,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 +732,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 +881,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 +927,31 @@ 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"
+            }
+        });
+        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){
         addDecisionRecord(session, {
@@ -972,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/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) {