@mandipadk7/kavi 0.1.3 → 0.1.5

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]",
@@ -247,6 +254,7 @@ async function ensureStartupReady(repoRoot, paths) {
         "node",
         "codex",
         "claude",
+        "claude-auth",
         "git-worktree",
         "codex-app-server",
         "codex-auth-file"
@@ -348,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")) {
@@ -367,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}`);
     }
@@ -428,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
@@ -444,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
@@ -454,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}`);
 }
@@ -476,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)
         }));
@@ -487,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 ?? "-"}`);
     }
 }
@@ -528,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:");
@@ -543,6 +570,7 @@ async function commandTaskOutput(cwd, args) {
     } else {
         for (const note of artifact.reviewNotes){
             console.log(`${note.createdAt} | ${note.disposition} | ${note.status} | ${note.filePath}${note.hunkIndex === null ? "" : ` | hunk ${note.hunkIndex + 1}`}`);
+            console.log(`  assignee: ${note.assignee ?? "-"}`);
             console.log(`  comments: ${note.comments.length}`);
             for (const [index, comment] of note.comments.entries()){
                 console.log(`  ${index === 0 ? "root" : `reply-${index}`}: ${comment.body}`);
@@ -575,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) {
@@ -601,20 +632,25 @@ 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){
         console.log(`${note.id} | ${note.agent} | ${note.status} | ${note.disposition} | ${note.filePath}${note.hunkIndex === null ? "" : ` | hunk ${note.hunkIndex + 1}`}`);
         console.log(`  task: ${note.taskId ?? "-"}`);
+        console.log(`  assignee: ${note.assignee ?? "-"}`);
         console.log(`  updated: ${note.updatedAt}`);
         console.log(`  comments: ${note.comments.length}`);
         console.log(`  landed: ${note.landedAt ?? "-"}`);
@@ -745,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, {
@@ -785,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

@@ -5,11 +5,21 @@ function trimBody(value) {
     return value.trim();
 }
 function summarizeReviewNote(disposition, filePath, hunkHeader, body) {
-    const label = disposition[0].toUpperCase() + disposition.slice(1);
+    const label = reviewDispositionSummaryLabel(disposition);
     const scope = hunkHeader ? `${filePath} ${hunkHeader}` : filePath;
     const firstLine = trimBody(body).split("\n")[0]?.trim() ?? "";
     return firstLine ? `${label} ${scope}: ${firstLine}` : `${label} ${scope}`;
 }
+function reviewDispositionSummaryLabel(disposition) {
+    switch(disposition){
+        case "accepted_risk":
+            return "Accepted Risk";
+        case "wont_fix":
+            return "Won't Fix";
+        default:
+            return disposition[0].toUpperCase() + disposition.slice(1);
+    }
+}
 function createReviewComment(body) {
     const timestamp = nowIso();
     return {
@@ -24,6 +34,7 @@ export function addReviewNote(session, input) {
     const note = {
         id: randomUUID(),
         agent: input.agent,
+        assignee: input.assignee ?? input.agent,
         taskId: input.taskId ?? null,
         filePath: input.filePath,
         hunkIndex: input.hunkIndex ?? null,
@@ -61,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) {
@@ -68,8 +103,10 @@ export function updateReviewNote(session, noteId, input) {
     }
     const nextBody = typeof input.body === "string" ? trimBody(input.body) : note.body;
     const nextDisposition = input.disposition ?? note.disposition;
+    const nextAssignee = input.assignee === undefined ? note.assignee : input.assignee;
     note.body = nextBody;
     note.disposition = nextDisposition;
+    note.assignee = nextAssignee;
     if (note.comments.length === 0) {
         note.comments.push(createReviewComment(nextBody));
     } else if (typeof input.body === "string") {
@@ -96,7 +133,7 @@ export function setReviewNoteStatus(session, noteId, status) {
     note.updatedAt = nowIso();
     return note;
 }
-export function linkReviewFollowUpTask(session, noteId, taskId) {
+export function linkReviewFollowUpTask(session, noteId, taskId, assignee) {
     const note = session.reviewNotes.find((item)=>item.id === noteId) ?? null;
     if (!note) {
         return null;
@@ -107,6 +144,9 @@ export function linkReviewFollowUpTask(session, noteId, taskId) {
             taskId
         ])
     ];
+    if (assignee !== undefined) {
+        note.assignee = assignee;
+    }
     note.updatedAt = nowIso();
     return note;
 }
@@ -122,6 +162,19 @@ export function addReviewReply(session, noteId, body) {
     note.updatedAt = nowIso();
     return note;
 }
+export function cycleReviewAssignee(current, noteAgent) {
+    const sequence = [
+        noteAgent,
+        noteAgent === "codex" ? "claude" : "codex",
+        "operator",
+        null
+    ];
+    const index = sequence.findIndex((item)=>item === current);
+    if (index === -1) {
+        return noteAgent;
+    }
+    return sequence[(index + 1) % sequence.length] ?? null;
+}
 export function autoResolveReviewNotesForCompletedTask(session, taskId) {
     const resolved = [];
     for (const note of session.reviewNotes){

package/dist/router.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { CodexAppServerClient } from "./codex-app-server.js";
 import { findClaimConflicts } from "./decision-ledger.js";
 import { nowIso } from "./paths.js";
@@ -43,6 +44,65 @@ 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;
+    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;
+    }
+    return filePaths.filter((filePath)=>patterns.some((pattern)=>matchesPattern(filePath, pattern))).length;
+}
+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
+        })
+    };
+}
 export function extractPromptPathHints(prompt) {
     const candidates = [];
     const quotedMatches = prompt.matchAll(/[`'"]([^`'"\n]+)[`'"]/g);
@@ -59,6 +119,10 @@ export function extractPromptPathHints(prompt) {
     return normalizeClaimedPaths(candidates);
 }
 export function routePrompt(prompt, config) {
+    const pathDecision = buildPathOwnershipDecision(prompt, config);
+    if (pathDecision) {
+        return pathDecision.owner;
+    }
     if (containsKeyword(prompt, config.routing.frontendKeywords)) {
         return "claude";
     }
@@ -77,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) {
@@ -86,12 +154,21 @@ 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;
 }
 function buildRouterPrompt(prompt, session) {
+    const ownershipRules = [
+        ...session.config.routing.codexPaths.map((pattern)=>`- codex: ${pattern}`),
+        ...session.config.routing.claudePaths.map((pattern)=>`- claude: ${pattern}`)
+    ].join("\n");
+    const promptHints = extractPromptPathHints(prompt);
     const activeClaims = session.pathClaims.filter((claim)=>claim.status === "active").map((claim)=>`- ${claim.agent}: ${claim.paths.join(", ")}`).join("\n");
     return [
         "Route this task between Codex and Claude.",
@@ -103,6 +180,12 @@ function buildRouterPrompt(prompt, session) {
         "Task prompt:",
         prompt,
         "",
+        "Explicit path ownership rules:",
+        ownershipRules || "- none",
+        "",
+        "Path hints extracted from the prompt:",
+        promptHints.length > 0 ? promptHints.map((item)=>`- ${item}`).join("\n") : "- none",
+        "",
         "Active path claims:",
         activeClaims || "- none"
     ].join("\n");
@@ -149,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();
@@ -170,10 +257,25 @@ 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) {
+    const pathDecision = buildPathOwnershipDecision(prompt, session.config);
+    if (pathDecision) {
+        return applyClaimRouting(session, pathDecision);
+    }
     const heuristic = buildKeywordDecision(prompt, session.config);
     if (heuristic) {
         return applyClaimRouting(session, heuristic);
@@ -187,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)
+            })
         });
     }
 }
@@ -204,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: []
         },
         {
@@ -216,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: []
         }
     ];
@@ -232,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
@@ -130,13 +131,22 @@ export async function rpcAddReviewNote(paths, params) {
         hunkIndex: params.hunkIndex,
         hunkHeader: params.hunkHeader,
         disposition: params.disposition,
+        assignee: params.assignee ?? null,
         body: params.body
     });
 }
 export async function rpcUpdateReviewNote(paths, params) {
     await sendRpcRequest(paths, "updateReviewNote", {
         noteId: params.noteId,
-        body: params.body
+        ...typeof params.body === "string" ? {
+            body: params.body
+        } : {},
+        ...params.disposition ? {
+            disposition: params.disposition
+        } : {},
+        ...params.assignee === undefined ? {} : {
+            assignee: params.assignee
+        }
     });
 }
 export async function rpcAddReviewReply(paths, params) {

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 : [];
@@ -59,9 +62,11 @@ export async function loadSessionRecord(paths) {
     record.reviewNotes = Array.isArray(record.reviewNotes) ? record.reviewNotes.map((note)=>({
             ...note,
             body: typeof note.body === "string" ? note.body : "",
+            assignee: note.assignee === "codex" || note.assignee === "claude" || note.assignee === "operator" ? note.assignee : null,
             taskId: typeof note.taskId === "string" ? note.taskId : null,
             hunkIndex: typeof note.hunkIndex === "number" ? note.hunkIndex : null,
             hunkHeader: typeof note.hunkHeader === "string" ? note.hunkHeader : null,
+            disposition: note.disposition === "approve" || note.disposition === "concern" || note.disposition === "question" || note.disposition === "accepted_risk" || note.disposition === "wont_fix" ? note.disposition : "note",
             status: note.status === "resolved" ? "resolved" : "open",
             comments: Array.isArray(note.comments) ? note.comments.map((comment)=>({
                     id: String(comment.id),

package/dist/task-artifacts.js

@@ -8,13 +8,18 @@ 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)=>({
                 ...note,
+                assignee: note.assignee === "codex" || note.assignee === "claude" || note.assignee === "operator" ? note.assignee : null,
                 taskId: typeof note.taskId === "string" ? note.taskId : null,
                 hunkIndex: typeof note.hunkIndex === "number" ? note.hunkIndex : null,
                 hunkHeader: typeof note.hunkHeader === "string" ? note.hunkHeader : null,
+                disposition: note.disposition === "approve" || note.disposition === "concern" || note.disposition === "question" || note.disposition === "accepted_risk" || note.disposition === "wont_fix" ? note.disposition : "note",
                 status: note.status === "resolved" ? "resolved" : "open",
                 summary: typeof note.summary === "string" ? note.summary : "",
                 body: typeof note.body === "string" ? note.body : "",