@mandipadk7/kavi 0.1.2 → 0.1.3

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",
@@ -239,8 +297,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 +341,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 +364,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 +372,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 +537,20 @@ 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(`  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 +597,31 @@ 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(`  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 +785,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 +987,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,159 @@
+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 = disposition[0].toUpperCase() + disposition.slice(1);
+    const scope = hunkHeader ? `${filePath} ${hunkHeader}` : filePath;
+    const firstLine = trimBody(body).split("\n")[0]?.trim() ?? "";
+    return firstLine ? `${label} ${scope}: ${firstLine}` : `${label} ${scope}`;
+}
+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,
+        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;
+    note.body = nextBody;
+    note.disposition = nextDisposition;
+    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) {
+    const note = session.reviewNotes.find((item)=>item.id === noteId) ?? null;
+    if (!note) {
+        return null;
+    }
+    note.followUpTaskIds = [
+        ...new Set([
+            ...note.followUpTaskIds,
+            taskId
+        ])
+    ];
+    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 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

package/dist/rpc.js

@@ -122,6 +122,42 @@ export async function rpcRecentEvents(paths, limit) {
         limit
     });
 }
+export async function rpcAddReviewNote(paths, params) {
+    await sendRpcRequest(paths, "addReviewNote", {
+        agent: params.agent,
+        taskId: params.taskId,
+        filePath: params.filePath,
+        hunkIndex: params.hunkIndex,
+        hunkHeader: params.hunkHeader,
+        disposition: params.disposition,
+        body: params.body
+    });
+}
+export async function rpcUpdateReviewNote(paths, params) {
+    await sendRpcRequest(paths, "updateReviewNote", {
+        noteId: params.noteId,
+        body: params.body
+    });
+}
+export async function rpcAddReviewReply(paths, params) {
+    await sendRpcRequest(paths, "addReviewReply", {
+        noteId: params.noteId,
+        body: params.body
+    });
+}
+export async function rpcSetReviewNoteStatus(paths, params) {
+    await sendRpcRequest(paths, "setReviewNoteStatus", {
+        noteId: params.noteId,
+        status: params.status
+    });
+}
+export async function rpcEnqueueReviewFollowUp(paths, params) {
+    await sendRpcRequest(paths, "enqueueReviewFollowUp", {
+        noteId: params.noteId,
+        owner: params.owner,
+        mode: params.mode
+    });
+}
 export async function rpcWorktreeDiff(paths, agent, filePath) {
     return await sendRpcRequest(paths, "worktreeDiff", {
         agent,

package/dist/session.js

@@ -35,6 +35,7 @@ export async function createSessionRecord(paths, config, runtime, sessionId, bas
         peerMessages: [],
         decisions: [],
         pathClaims: [],
+        reviewNotes: [],
         agentStatus: {
             codex: initialAgentStatus("codex", "codex-app-server"),
             claude: initialAgentStatus("claude", "claude-print")
@@ -55,6 +56,30 @@ export async function loadSessionRecord(paths) {
         })) : [];
     record.decisions = Array.isArray(record.decisions) ? record.decisions : [];
     record.pathClaims = Array.isArray(record.pathClaims) ? record.pathClaims : [];
+    record.reviewNotes = Array.isArray(record.reviewNotes) ? record.reviewNotes.map((note)=>({
+            ...note,
+            body: typeof note.body === "string" ? note.body : "",
+            taskId: typeof note.taskId === "string" ? note.taskId : null,
+            hunkIndex: typeof note.hunkIndex === "number" ? note.hunkIndex : null,
+            hunkHeader: typeof note.hunkHeader === "string" ? note.hunkHeader : null,
+            status: note.status === "resolved" ? "resolved" : "open",
+            comments: Array.isArray(note.comments) ? note.comments.map((comment)=>({
+                    id: String(comment.id),
+                    body: typeof comment.body === "string" ? comment.body : "",
+                    createdAt: String(comment.createdAt),
+                    updatedAt: String(comment.updatedAt)
+                })) : typeof note.body === "string" && note.body ? [
+                {
+                    id: `${note.id}-root`,
+                    body: note.body,
+                    createdAt: typeof note.createdAt === "string" ? note.createdAt : nowIso(),
+                    updatedAt: typeof note.updatedAt === "string" ? note.updatedAt : nowIso()
+                }
+            ] : [],
+            resolvedAt: typeof note.resolvedAt === "string" ? note.resolvedAt : null,
+            landedAt: typeof note.landedAt === "string" ? note.landedAt : null,
+            followUpTaskIds: Array.isArray(note.followUpTaskIds) ? note.followUpTaskIds.map((item)=>String(item)) : []
+        })) : [];
     return record;
 }
 export async function saveSessionRecord(paths, record) {

package/dist/task-artifacts.js

@@ -9,7 +9,32 @@ function normalizeArtifact(artifact) {
         ...artifact,
         routeReason: typeof artifact.routeReason === "string" ? artifact.routeReason : null,
         claimedPaths: Array.isArray(artifact.claimedPaths) ? artifact.claimedPaths.map((item)=>String(item)) : [],
-        decisionReplay: Array.isArray(artifact.decisionReplay) ? artifact.decisionReplay.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,
+                taskId: typeof note.taskId === "string" ? note.taskId : null,
+                hunkIndex: typeof note.hunkIndex === "number" ? note.hunkIndex : null,
+                hunkHeader: typeof note.hunkHeader === "string" ? note.hunkHeader : null,
+                status: note.status === "resolved" ? "resolved" : "open",
+                summary: typeof note.summary === "string" ? note.summary : "",
+                body: typeof note.body === "string" ? note.body : "",
+                comments: Array.isArray(note.comments) ? note.comments.map((comment)=>({
+                        id: String(comment.id),
+                        body: typeof comment.body === "string" ? comment.body : "",
+                        createdAt: String(comment.createdAt),
+                        updatedAt: String(comment.updatedAt)
+                    })) : typeof note.body === "string" && note.body ? [
+                    {
+                        id: `${note.id}-root`,
+                        body: note.body,
+                        createdAt: typeof note.createdAt === "string" ? note.createdAt : artifact.startedAt,
+                        updatedAt: typeof note.updatedAt === "string" ? note.updatedAt : artifact.finishedAt
+                    }
+                ] : [],
+                resolvedAt: typeof note.resolvedAt === "string" ? note.resolvedAt : null,
+                landedAt: typeof note.landedAt === "string" ? note.landedAt : null,
+                followUpTaskIds: Array.isArray(note.followUpTaskIds) ? note.followUpTaskIds.map((item)=>String(item)) : []
+            })) : []
     };
 }
 export async function saveTaskArtifact(paths, artifact) {