@mandipadk7/kavi 0.1.2 → 0.1.4

package/dist/git.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { ensureDir } from "./fs.js";
 import { buildSessionId } from "./paths.js";
 import { runCommand } from "./process.js";
-export async function detectRepoRoot(cwd) {
+export async function findRepoRoot(cwd) {
     const result = await runCommand("git", [
         "rev-parse",
         "--show-toplevel"
@@ -11,10 +11,17 @@ export async function detectRepoRoot(cwd) {
         cwd
     });
     if (result.code !== 0) {
-        throw new Error(result.stderr.trim() || "Not inside a git repository.");
+        return null;
     }
     return result.stdout.trim();
 }
+export async function detectRepoRoot(cwd) {
+    const repoRoot = await findRepoRoot(cwd);
+    if (!repoRoot) {
+        throw new Error("Not inside a git repository.");
+    }
+    return repoRoot;
+}
 export async function getHeadCommit(repoRoot) {
     const result = await runCommand("git", [
         "rev-parse",
@@ -27,6 +34,98 @@ export async function getHeadCommit(repoRoot) {
     }
     return result.stdout.trim();
 }
+async function initializeRepository(repoRoot) {
+    const preferred = await runCommand("git", [
+        "init",
+        "--initial-branch=main"
+    ], {
+        cwd: repoRoot
+    });
+    if (preferred.code === 0) {
+        return;
+    }
+    const fallback = await runCommand("git", [
+        "init"
+    ], {
+        cwd: repoRoot
+    });
+    if (fallback.code !== 0) {
+        throw new Error(fallback.stderr.trim() || preferred.stderr.trim() || `Unable to initialize git in ${repoRoot}.`);
+    }
+}
+export async function ensureGitRepository(cwd) {
+    const existing = await findRepoRoot(cwd);
+    if (existing) {
+        return {
+            repoRoot: existing,
+            createdRepository: false
+        };
+    }
+    await initializeRepository(cwd);
+    return {
+        repoRoot: await detectRepoRoot(cwd),
+        createdRepository: true
+    };
+}
+export async function hasHeadCommit(repoRoot) {
+    const result = await runCommand("git", [
+        "rev-parse",
+        "--verify",
+        "HEAD"
+    ], {
+        cwd: repoRoot
+    });
+    return result.code === 0;
+}
+export async function ensureBootstrapCommit(repoRoot, message = "kavi: bootstrap project") {
+    if (await hasHeadCommit(repoRoot)) {
+        return {
+            createdCommit: false,
+            commit: await getHeadCommit(repoRoot),
+            stagedPaths: []
+        };
+    }
+    const add = await runCommand("git", [
+        "add",
+        "-A"
+    ], {
+        cwd: repoRoot
+    });
+    if (add.code !== 0) {
+        throw new Error(add.stderr.trim() || `Unable to stage bootstrap files in ${repoRoot}.`);
+    }
+    const staged = await runCommand("git", [
+        "diff",
+        "--cached",
+        "--name-only",
+        "--diff-filter=ACMRTUXB"
+    ], {
+        cwd: repoRoot
+    });
+    if (staged.code !== 0) {
+        throw new Error(staged.stderr.trim() || `Unable to inspect staged bootstrap files in ${repoRoot}.`);
+    }
+    const commit = await runCommand("git", [
+        "-c",
+        "user.name=Kavi",
+        "-c",
+        "user.email=kavi@local.invalid",
+        "commit",
+        "--allow-empty",
+        "-m",
+        message
+    ], {
+        cwd: repoRoot
+    });
+    if (commit.code !== 0) {
+        throw new Error(commit.stderr.trim() || `Unable to create bootstrap commit in ${repoRoot}.`);
+    }
+    return {
+        createdCommit: true,
+        commit: await getHeadCommit(repoRoot),
+        stagedPaths: parsePathList(staged.stdout)
+    };
+}
 export async function getCurrentBranch(repoRoot) {
     const result = await runCommand("git", [
         "branch",

package/dist/main.js

@@ -9,14 +9,15 @@ import { KaviDaemon } from "./daemon.js";
 import { addDecisionRecord, upsertPathClaim } from "./decision-ledger.js";
 import { runDoctor } from "./doctor.js";
 import { writeJson } from "./fs.js";
-import { createGitignoreEntries, detectRepoRoot, ensureWorktrees, findOverlappingWorktreePaths, getHeadCommit, landBranches, resolveTargetBranch } from "./git.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 { resolveSessionRuntime } from "./runtime.js";
 import { buildAdHocTask, extractPromptPathHints, routeTask } from "./router.js";
-import { createSessionRecord, loadSessionRecord, readRecentEvents, recordEvent, sessionExists, sessionHeartbeatAgeMs } from "./session.js";
-import { listTaskArtifacts, loadTaskArtifact } from "./task-artifacts.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";
 const HEARTBEAT_STALE_MS = 10_000;
 const CLAUDE_AUTO_ALLOW_TOOLS = new Set([
@@ -59,7 +60,7 @@ async function readStdinText() {
 function renderUsage() {
     return [
         "Usage:",
-        "  kavi init [--home]",
+        "  kavi init [--home] [--no-commit]",
         "  kavi doctor [--json]",
         "  kavi start [--goal \"...\"]",
         "  kavi open [--goal \"...\"]",
@@ -71,6 +72,7 @@ function renderUsage() {
         "  kavi task-output <task-id|latest> [--json]",
         "  kavi decisions [--json] [--limit N]",
         "  kavi claims [--json] [--all]",
+        "  kavi reviews [--json] [--all]",
         "  kavi approvals [--json] [--all]",
         "  kavi approve <request-id|latest> [--remember]",
         "  kavi deny <request-id|latest> [--remember]",
@@ -111,22 +113,65 @@ async function waitForSession(paths, expectedState = "running") {
     }
     throw new Error(`Timed out waiting for session state ${expectedState} in ${paths.stateFile}.`);
 }
-async function commandInit(cwd, args) {
-    const repoRoot = await detectRepoRoot(cwd);
+async function prepareProjectContext(cwd, options) {
+    let repoRoot;
+    let createdRepository = false;
+    let hasGitRepository = false;
+    if (options.createRepository) {
+        const repository = await ensureGitRepository(cwd);
+        repoRoot = repository.repoRoot;
+        createdRepository = repository.createdRepository;
+        hasGitRepository = true;
+    } else {
+        const existingRepoRoot = await findRepoRoot(cwd);
+        repoRoot = existingRepoRoot ?? cwd;
+        hasGitRepository = existingRepoRoot !== null;
+    }
     const paths = resolveAppPaths(repoRoot);
     await ensureProjectScaffold(paths);
-    await createGitignoreEntries(repoRoot);
-    if (args.includes("--home")) {
+    if (hasGitRepository) {
+        await createGitignoreEntries(repoRoot);
+    }
+    if (options.ensureHomeConfig) {
         await ensureHomeConfig(paths);
-        console.log(`Initialized user-local Kavi config in ${paths.homeConfigFile}`);
     }
-    console.log(`Initialized Kavi project scaffold in ${paths.kaviDir}`);
+    return {
+        repoRoot,
+        paths,
+        createdRepository,
+        bootstrapCommit: options.ensureHeadCommit ? await ensureBootstrapCommit(repoRoot) : null
+    };
+}
+async function commandInit(cwd, args) {
+    const skipCommit = args.includes("--no-commit");
+    const prepared = await prepareProjectContext(cwd, {
+        createRepository: true,
+        ensureHeadCommit: !skipCommit,
+        ensureHomeConfig: args.includes("--home")
+    });
+    if (args.includes("--home")) {
+        console.log(`Initialized user-local Kavi config in ${prepared.paths.homeConfigFile}`);
+    }
+    if (prepared.createdRepository) {
+        console.log(`Initialized git repository in ${prepared.repoRoot}`);
+    }
+    console.log(`Initialized Kavi project scaffold in ${prepared.paths.kaviDir}`);
+    if (skipCommit) {
+        console.log("Skipped bootstrap commit creation (--no-commit).");
+        console.log('Kavi will create the first base commit automatically on "kavi open" or "kavi start".');
+        return;
+    }
+    if (prepared.bootstrapCommit?.createdCommit) {
+        console.log(`Created bootstrap commit ${prepared.bootstrapCommit.commit.slice(0, 12)} with ${prepared.bootstrapCommit.stagedPaths.length} tracked path${prepared.bootstrapCommit.stagedPaths.length === 1 ? "" : "s"}.`);
+    }
 }
 async function commandDoctor(cwd, args) {
-    const repoRoot = await detectRepoRoot(cwd);
-    const paths = resolveAppPaths(repoRoot);
-    await ensureProjectScaffold(paths);
-    const checks = await runDoctor(repoRoot, paths);
+    const prepared = await prepareProjectContext(cwd, {
+        createRepository: false,
+        ensureHeadCommit: false,
+        ensureHomeConfig: false
+    });
+    const checks = await runDoctor(prepared.repoRoot, prepared.paths);
     if (args.includes("--json")) {
         console.log(JSON.stringify(checks, null, 2));
         process.exitCode = checks.some((check)=>!check.ok) ? 1 : 0;
@@ -142,12 +187,12 @@ async function commandDoctor(cwd, args) {
     process.exitCode = failed ? 1 : 0;
 }
 async function startOrAttachSession(cwd, goal) {
-    const repoRoot = await detectRepoRoot(cwd);
-    const paths = resolveAppPaths(repoRoot);
-    await ensureProjectScaffold(paths);
-    await createGitignoreEntries(repoRoot);
-    await ensureHomeConfig(paths);
-    await ensureStartupReady(repoRoot, paths);
+    const prepared = await prepareProjectContext(cwd, {
+        createRepository: true,
+        ensureHeadCommit: false,
+        ensureHomeConfig: true
+    });
+    const { repoRoot, paths } = prepared;
     if (await sessionExists(paths)) {
         try {
             const session = await loadSessionRecord(paths);
@@ -163,14 +208,27 @@ async function startOrAttachSession(cwd, goal) {
             });
         } catch  {}
     }
+    await ensureStartupReady(repoRoot, paths);
     const config = await loadConfig(paths);
     const runtime = await resolveSessionRuntime(paths);
-    const baseCommit = await getHeadCommit(repoRoot);
+    const bootstrapCommit = await ensureBootstrapCommit(repoRoot);
+    const baseCommit = bootstrapCommit.commit;
     const sessionId = buildSessionId();
     const rpcEndpoint = paths.socketPath;
     await fs.writeFile(paths.commandsFile, "", "utf8");
     const worktrees = await ensureWorktrees(repoRoot, paths, sessionId, config, baseCommit);
     await createSessionRecord(paths, config, runtime, sessionId, baseCommit, worktrees, goal, rpcEndpoint);
+    if (prepared.createdRepository) {
+        await recordEvent(paths, sessionId, "repo.initialized", {
+            repoRoot
+        });
+    }
+    if (bootstrapCommit.createdCommit) {
+        await recordEvent(paths, sessionId, "repo.bootstrap_committed", {
+            commit: bootstrapCommit.commit,
+            stagedPaths: bootstrapCommit.stagedPaths
+        });
+    }
     const pid = spawnDetachedNode(runtime.nodeExecutable, [
         fileURLToPath(import.meta.url),
         "__daemon",
@@ -189,6 +247,7 @@ async function ensureStartupReady(repoRoot, paths) {
         "node",
         "codex",
         "claude",
+        "claude-auth",
         "git-worktree",
         "codex-app-server",
         "codex-auth-file"
@@ -239,8 +298,8 @@ async function commandResume(cwd) {
 }
 async function commandStart(cwd, args) {
     const goal = getGoal(args);
-    const repoRoot = await detectRepoRoot(cwd);
     const socketPath = await startOrAttachSession(cwd, goal);
+    const repoRoot = await detectRepoRoot(cwd);
     const paths = resolveAppPaths(repoRoot);
     const session = await loadSessionRecord(paths);
     console.log(`Started Kavi session ${session.id}`);
@@ -283,6 +342,10 @@ async function commandStatus(cwd, args) {
         decisionCounts: {
             total: session.decisions.length
         },
+        reviewCounts: {
+            open: session.reviewNotes.filter((note)=>note.status === "open").length,
+            total: session.reviewNotes.length
+        },
         pathClaimCounts: {
             active: session.pathClaims.filter((claim)=>claim.status === "active").length
         },
@@ -302,6 +365,7 @@ async function commandStatus(cwd, args) {
     console.log(`Runtime: node=${payload.runtime.nodeExecutable} codex=${payload.runtime.codexExecutable} claude=${payload.runtime.claudeExecutable}`);
     console.log(`Tasks: total=${payload.taskCounts.total} pending=${payload.taskCounts.pending} running=${payload.taskCounts.running} blocked=${payload.taskCounts.blocked} completed=${payload.taskCounts.completed} failed=${payload.taskCounts.failed}`);
     console.log(`Approvals: pending=${payload.approvalCounts.pending}`);
+    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}`);
     for (const worktree of payload.worktrees){
@@ -309,7 +373,7 @@ async function commandStatus(cwd, args) {
     }
 }
 async function commandPaths(cwd, args) {
-    const repoRoot = await detectRepoRoot(cwd);
+    const repoRoot = await findRepoRoot(cwd) ?? cwd;
     const paths = resolveAppPaths(repoRoot);
     const runtime = await resolveSessionRuntime(paths);
     const payload = {
@@ -474,6 +538,21 @@ async function commandTaskOutput(cwd, args) {
     }
     console.log("Envelope:");
     console.log(JSON.stringify(artifact.envelope, null, 2));
+    console.log("Review Notes:");
+    if (artifact.reviewNotes.length === 0) {
+        console.log("-");
+    } 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}`);
+            }
+            console.log(`  landed: ${note.landedAt ?? "-"}`);
+            console.log(`  follow-ups: ${note.followUpTaskIds.join(", ") || "-"}`);
+        }
+    }
     console.log("Raw Output:");
     console.log(artifact.rawOutput ?? "");
 }
@@ -520,6 +599,32 @@ async function commandClaims(cwd, args) {
         console.log(`  note: ${claim.note ?? "-"}`);
     }
 }
+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");
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(notes, null, 2));
+        return;
+    }
+    if (notes.length === 0) {
+        console.log("No review notes recorded.");
+        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 ?? "-"}`);
+        console.log(`  follow-ups: ${note.followUpTaskIds.join(", ") || "-"}`);
+        console.log(`  body: ${note.body}`);
+    }
+}
 async function commandApprovals(cwd, args) {
     const { paths } = await requireSession(cwd);
     const rpcSnapshot = await tryRpcSnapshot(paths);
@@ -683,6 +788,46 @@ async function commandLand(cwd) {
         snapshotCommits: result.snapshotCommits,
         commands: result.commandsRun
     });
+    const landedReviewNotes = markReviewNotesLandedForTasks(session, session.tasks.filter((task)=>task.status === "completed").map((task)=>task.id));
+    for (const note of landedReviewNotes){
+        addDecisionRecord(session, {
+            kind: "review",
+            agent: note.agent,
+            taskId: note.taskId,
+            summary: `Marked review note ${note.id} as landed`,
+            detail: `Follow-up work for ${note.filePath} is now part of ${targetBranch}.`,
+            metadata: {
+                reviewNoteId: note.id,
+                filePath: note.filePath,
+                landedAt: note.landedAt,
+                targetBranch
+            }
+        });
+        await recordEvent(paths, session.id, "review.note_landed", {
+            reviewNoteId: note.id,
+            taskId: note.taskId,
+            followUpTaskIds: note.followUpTaskIds,
+            agent: note.agent,
+            filePath: note.filePath,
+            landedAt: note.landedAt,
+            targetBranch
+        });
+    }
+    await saveSessionRecord(paths, session);
+    const artifactTaskIds = [
+        ...new Set(landedReviewNotes.flatMap((note)=>note.taskId ? [
+                note.taskId
+            ] : []))
+    ];
+    for (const taskId of artifactTaskIds){
+        const artifact = await loadTaskArtifact(paths, taskId);
+        if (!artifact) {
+            continue;
+        }
+        artifact.reviewNotes = session.reviewNotes.filter((note)=>note.taskId === taskId);
+        await saveTaskArtifact(paths, artifact);
+    }
+    await notifyOperatorSurface(paths, "land.completed");
     console.log(`Landed branches into ${targetBranch}`);
     console.log(`Integration branch: ${result.integrationBranch}`);
     console.log(`Integration worktree: ${result.integrationPath}`);
@@ -845,6 +990,9 @@ async function main() {
         case "claims":
             await commandClaims(cwd, args);
             break;
+        case "reviews":
+            await commandReviews(cwd, args);
+            break;
         case "approvals":
             await commandApprovals(cwd, args);
             break;

package/dist/reviews.js

@@ -0,0 +1,188 @@
+import { randomUUID } from "node:crypto";
+import { nowIso } from "./paths.js";
+const MAX_REVIEW_NOTES = 200;
+function trimBody(value) {
+    return value.trim();
+}
+function summarizeReviewNote(disposition, filePath, hunkHeader, body) {
+    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 {
+        id: randomUUID(),
+        body: trimBody(body),
+        createdAt: timestamp,
+        updatedAt: timestamp
+    };
+}
+export function addReviewNote(session, input) {
+    const timestamp = nowIso();
+    const note = {
+        id: randomUUID(),
+        agent: input.agent,
+        assignee: input.assignee ?? input.agent,
+        taskId: input.taskId ?? null,
+        filePath: input.filePath,
+        hunkIndex: input.hunkIndex ?? null,
+        hunkHeader: input.hunkHeader ?? null,
+        disposition: input.disposition,
+        status: "open",
+        summary: summarizeReviewNote(input.disposition, input.filePath, input.hunkHeader ?? null, input.body),
+        body: trimBody(input.body),
+        comments: [
+            createReviewComment(input.body)
+        ],
+        resolvedAt: null,
+        landedAt: null,
+        followUpTaskIds: [],
+        createdAt: timestamp,
+        updatedAt: timestamp
+    };
+    session.reviewNotes = [
+        ...session.reviewNotes,
+        note
+    ].slice(-MAX_REVIEW_NOTES);
+    return note;
+}
+export function reviewNotesForTask(session, taskId) {
+    return session.reviewNotes.filter((note)=>note.taskId === taskId);
+}
+export function reviewNotesForPath(session, agent, filePath, hunkIndex) {
+    return session.reviewNotes.filter((note)=>{
+        if (note.agent !== agent || note.filePath !== filePath) {
+            return false;
+        }
+        if (hunkIndex === undefined) {
+            return true;
+        }
+        return note.hunkIndex === hunkIndex;
+    });
+}
+export function updateReviewNote(session, noteId, input) {
+    const note = session.reviewNotes.find((item)=>item.id === noteId) ?? null;
+    if (!note) {
+        return null;
+    }
+    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") {
+        note.comments[0] = {
+            ...note.comments[0],
+            body: nextBody,
+            updatedAt: nowIso()
+        };
+    }
+    note.summary = summarizeReviewNote(nextDisposition, note.filePath, note.hunkHeader, nextBody);
+    note.updatedAt = nowIso();
+    return note;
+}
+export function setReviewNoteStatus(session, noteId, status) {
+    const note = session.reviewNotes.find((item)=>item.id === noteId) ?? null;
+    if (!note) {
+        return null;
+    }
+    note.status = status;
+    note.resolvedAt = status === "resolved" ? nowIso() : null;
+    if (status === "open") {
+        note.landedAt = null;
+    }
+    note.updatedAt = nowIso();
+    return note;
+}
+export function linkReviewFollowUpTask(session, noteId, taskId, assignee) {
+    const note = session.reviewNotes.find((item)=>item.id === noteId) ?? null;
+    if (!note) {
+        return null;
+    }
+    note.followUpTaskIds = [
+        ...new Set([
+            ...note.followUpTaskIds,
+            taskId
+        ])
+    ];
+    if (assignee !== undefined) {
+        note.assignee = assignee;
+    }
+    note.updatedAt = nowIso();
+    return note;
+}
+export function addReviewReply(session, noteId, body) {
+    const note = session.reviewNotes.find((item)=>item.id === noteId) ?? null;
+    if (!note) {
+        return null;
+    }
+    note.comments.push(createReviewComment(body));
+    note.status = "open";
+    note.resolvedAt = null;
+    note.landedAt = null;
+    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){
+        if (note.status !== "open" || !note.followUpTaskIds.includes(taskId)) {
+            continue;
+        }
+        note.status = "resolved";
+        note.resolvedAt = nowIso();
+        note.updatedAt = nowIso();
+        resolved.push(note);
+    }
+    return resolved;
+}
+export function markReviewNotesLandedForTasks(session, taskIds) {
+    if (taskIds.length === 0) {
+        return [];
+    }
+    const landedTaskIds = new Set(taskIds);
+    const landed = [];
+    for (const note of session.reviewNotes){
+        if (note.status !== "resolved" || note.landedAt !== null) {
+            continue;
+        }
+        if (!note.followUpTaskIds.some((taskId)=>landedTaskIds.has(taskId))) {
+            continue;
+        }
+        note.landedAt = nowIso();
+        note.updatedAt = nowIso();
+        landed.push(note);
+    }
+    return landed;
+}
+
+
+//# sourceURL=reviews.ts