@mandipadk7/kavi 0.1.1 → 0.1.2

package/dist/main.js

@@ -12,6 +12,7 @@ import { writeJson } from "./fs.js";
 import { createGitignoreEntries, detectRepoRoot, ensureWorktrees, findOverlappingWorktreePaths, getHeadCommit, 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 { resolveSessionRuntime } from "./runtime.js";
 import { buildAdHocTask, extractPromptPathHints, routeTask } from "./router.js";
 import { createSessionRecord, loadSessionRecord, readRecentEvents, recordEvent, sessionExists, sessionHeartbeatAgeMs } from "./session.js";
@@ -68,6 +69,8 @@ function renderUsage() {
         "  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 approvals [--json] [--all]",
         "  kavi approve <request-id|latest> [--remember]",
         "  kavi deny <request-id|latest> [--remember]",
@@ -96,7 +99,7 @@ async function waitForSession(paths, expectedState = "running") {
         try {
             if (await sessionExists(paths)) {
                 const session = await loadSessionRecord(paths);
-                if (expectedState === "running" && isSessionLive(session)) {
+                if (expectedState === "running" && isSessionLive(session) && await pingRpc(paths)) {
                     return;
                 }
                 if (expectedState === "stopped" && session.status === "stopped") {
@@ -148,11 +151,9 @@ async function startOrAttachSession(cwd, goal) {
     if (await sessionExists(paths)) {
         try {
             const session = await loadSessionRecord(paths);
-            if (isSessionLive(session)) {
+            if (isSessionLive(session) && await pingRpc(paths)) {
                 if (goal) {
-                    await appendCommand(paths, "kickoff", {
-                        prompt: goal
-                    });
+                    await rpcKickoff(paths, goal);
                 }
                 return session.socketPath;
             }
@@ -166,7 +167,7 @@ async function startOrAttachSession(cwd, goal) {
     const runtime = await resolveSessionRuntime(paths);
     const baseCommit = await getHeadCommit(repoRoot);
     const sessionId = buildSessionId();
-    const rpcEndpoint = "file://session-state";
+    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);
@@ -210,6 +211,20 @@ async function requireSession(cwd) {
         paths
     };
 }
+async function tryRpcSnapshot(paths) {
+    if (!await pingRpc(paths)) {
+        return null;
+    }
+    return await readSnapshot(paths);
+}
+async function notifyOperatorSurface(paths, reason) {
+    if (!await pingRpc(paths)) {
+        return;
+    }
+    try {
+        await rpcNotifyExternalUpdate(paths, reason);
+    } catch  {}
+}
 async function commandOpen(cwd, args) {
     const goal = getGoal(args);
     await startOrAttachSession(cwd, goal);
@@ -238,17 +253,20 @@ async function commandStart(cwd, args) {
 }
 async function commandStatus(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const session = await loadSessionRecord(paths);
-    const pendingApprovals = await listApprovalRequests(paths);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
+    const pendingApprovals = rpcSnapshot?.approvals.filter((item)=>item.status === "pending") ?? await listApprovalRequests(paths);
     const heartbeatAgeMs = sessionHeartbeatAgeMs(session);
     const payload = {
         id: session.id,
         status: session.status,
         repoRoot: session.repoRoot,
+        socketPath: session.socketPath,
         goal: session.goal,
         daemonPid: session.daemonPid,
         daemonHeartbeatAt: session.daemonHeartbeatAt,
         daemonHealthy: isSessionLive(session),
+        rpcConnected: rpcSnapshot !== null,
         heartbeatAgeMs,
         runtime: session.runtime,
         taskCounts: {
@@ -277,6 +295,7 @@ async function commandStatus(cwd, args) {
     console.log(`Session: ${payload.id}`);
     console.log(`Status: ${payload.status}${payload.daemonHealthy ? " (healthy)" : " (stale or stopped)"}`);
     console.log(`Repo: ${payload.repoRoot}`);
+    console.log(`Control: ${payload.socketPath}${payload.rpcConnected ? " (connected)" : " (disconnected)"}`);
     console.log(`Goal: ${payload.goal ?? "-"}`);
     console.log(`Daemon PID: ${payload.daemonPid ?? "-"}`);
     console.log(`Heartbeat: ${payload.daemonHeartbeatAt ?? "-"}${heartbeatAgeMs === null ? "" : ` (${heartbeatAgeMs} ms ago)`}`);
@@ -305,6 +324,7 @@ async function commandPaths(cwd, args) {
         eventsFile: paths.eventsFile,
         approvalsFile: paths.approvalsFile,
         commandsFile: paths.commandsFile,
+        socketPath: paths.socketPath,
         runsDir: paths.runsDir,
         claudeSettingsFile: paths.claudeSettingsFile,
         homeApprovalRulesFile: paths.homeApprovalRulesFile,
@@ -325,6 +345,7 @@ async function commandPaths(cwd, args) {
     console.log(`Events file: ${payload.eventsFile}`);
     console.log(`Approvals file: ${payload.approvalsFile}`);
     console.log(`Command queue: ${payload.commandsFile}`);
+    console.log(`Control socket: ${payload.socketPath}`);
     console.log(`Task artifacts: ${payload.runsDir}`);
     console.log(`Claude settings: ${payload.claudeSettingsFile}`);
     console.log(`Approval rules: ${payload.homeApprovalRulesFile}`);
@@ -332,7 +353,8 @@ async function commandPaths(cwd, args) {
 }
 async function commandTask(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const session = await loadSessionRecord(paths);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
     const requestedAgent = getFlag(args, "--agent");
     const prompt = getGoal(args.filter((arg, index)=>arg !== "--agent" && args[index - 1] !== "--agent"));
     if (!prompt) {
@@ -345,14 +367,25 @@ async function commandTask(cwd, args) {
         reason: `User explicitly assigned the task to ${requestedAgent}.`,
         claimedPaths: extractPromptPathHints(prompt)
     } : await routeTask(prompt, session, paths);
-    await appendCommand(paths, "enqueue", {
-        owner: routeDecision.owner,
-        prompt,
-        routeReason: routeDecision.reason,
-        claimedPaths: routeDecision.claimedPaths,
-        routeStrategy: routeDecision.strategy,
-        routeConfidence: routeDecision.confidence
-    });
+    if (rpcSnapshot) {
+        await rpcEnqueueTask(paths, {
+            owner: routeDecision.owner,
+            prompt,
+            routeReason: routeDecision.reason,
+            claimedPaths: routeDecision.claimedPaths,
+            routeStrategy: routeDecision.strategy,
+            routeConfidence: routeDecision.confidence
+        });
+    } else {
+        await appendCommand(paths, "enqueue", {
+            owner: routeDecision.owner,
+            prompt,
+            routeReason: routeDecision.reason,
+            claimedPaths: routeDecision.claimedPaths,
+            routeStrategy: routeDecision.strategy,
+            routeConfidence: routeDecision.confidence
+        });
+    }
     await recordEvent(paths, session.id, "task.cli_enqueued", {
         owner: routeDecision.owner,
         prompt,
@@ -364,7 +397,8 @@ async function commandTask(cwd, args) {
 }
 async function commandTasks(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const session = await loadSessionRecord(paths);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
     const artifacts = await listTaskArtifacts(paths);
     const artifactMap = new Map(artifacts.map((artifact)=>[
             artifact.taskId,
@@ -411,12 +445,13 @@ function resolveRequestedTaskId(args, knownTaskIds) {
 }
 async function commandTaskOutput(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const session = await loadSessionRecord(paths);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
     const sortedTasks = [
         ...session.tasks
     ].sort((left, right)=>left.updatedAt.localeCompare(right.updatedAt));
     const taskId = resolveRequestedTaskId(args, sortedTasks.map((task)=>task.id));
-    const artifact = await loadTaskArtifact(paths, taskId);
+    const artifact = rpcSnapshot ? await rpcTaskArtifact(paths, taskId) : await loadTaskArtifact(paths, taskId);
     if (!artifact) {
         throw new Error(`No task artifact found for ${taskId}.`);
     }
@@ -430,15 +465,65 @@ 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(`Claimed paths: ${artifact.claimedPaths.join(", ") || "-"}`);
     console.log(`Error: ${artifact.error ?? "-"}`);
+    console.log("Decision Replay:");
+    for (const line of artifact.decisionReplay){
+        console.log(line);
+    }
     console.log("Envelope:");
     console.log(JSON.stringify(artifact.envelope, null, 2));
     console.log("Raw Output:");
     console.log(artifact.rawOutput ?? "");
 }
+async function commandDecisions(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 decisions = [
+        ...session.decisions
+    ].sort((left, right)=>left.createdAt.localeCompare(right.createdAt)).slice(-Math.max(1, Number.isFinite(limit) ? limit : 20));
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(decisions, null, 2));
+        return;
+    }
+    if (decisions.length === 0) {
+        console.log("No decisions recorded.");
+        return;
+    }
+    for (const decision of decisions){
+        console.log(`${decision.createdAt} | ${decision.kind} | ${decision.agent ?? "-"} | ${decision.summary}`);
+        console.log(`  task: ${decision.taskId ?? "-"}`);
+        console.log(`  detail: ${decision.detail}`);
+    }
+}
+async function commandClaims(cwd, args) {
+    const { paths } = await requireSession(cwd);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const session = rpcSnapshot?.session ?? await loadSessionRecord(paths);
+    const claims = args.includes("--all") ? session.pathClaims : session.pathClaims.filter((claim)=>claim.status === "active");
+    if (args.includes("--json")) {
+        console.log(JSON.stringify(claims, null, 2));
+        return;
+    }
+    if (claims.length === 0) {
+        console.log("No path claims recorded.");
+        return;
+    }
+    for (const claim of claims){
+        console.log(`${claim.id} | ${claim.agent} | ${claim.status} | ${claim.source} | ${claim.paths.join(", ") || "-"}`);
+        console.log(`  task: ${claim.taskId}`);
+        console.log(`  updated: ${claim.updatedAt}`);
+        console.log(`  note: ${claim.note ?? "-"}`);
+    }
+}
 async function commandApprovals(cwd, args) {
     const { paths } = await requireSession(cwd);
-    const requests = await listApprovalRequests(paths, {
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const requests = rpcSnapshot ? rpcSnapshot.approvals.filter((request)=>args.includes("--all") || request.status === "pending") : await listApprovalRequests(paths, {
         includeResolved: args.includes("--all")
     });
     if (args.includes("--json")) {
@@ -469,40 +554,54 @@ function resolveApprovalRequestId(requests, requested) {
 }
 async function commandResolveApproval(cwd, args, decision) {
     const { paths } = await requireSession(cwd);
-    const requests = await listApprovalRequests(paths, {
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const requests = rpcSnapshot?.approvals ?? await listApprovalRequests(paths, {
         includeResolved: true
     });
     const requestedId = args.find((arg)=>!arg.startsWith("--")) ?? "latest";
     const requestId = resolveApprovalRequestId(requests, requestedId);
     const remember = args.includes("--remember");
-    const request = await resolveApprovalRequest(paths, requestId, decision, remember);
-    const session = await loadSessionRecord(paths);
-    addDecisionRecord(session, {
-        kind: "approval",
-        agent: request.agent,
-        summary: `${decision === "allow" ? "Approved" : "Denied"} ${request.toolName}`,
-        detail: request.summary,
-        metadata: {
-            requestId: request.id,
+    const request = requests.find((item)=>item.id === requestId);
+    if (!request) {
+        throw new Error(`Approval request ${requestId} not found.`);
+    }
+    if (rpcSnapshot) {
+        await rpcResolveApproval(paths, {
+            requestId,
+            decision,
+            remember
+        });
+    } else {
+        const resolved = await resolveApprovalRequest(paths, requestId, decision, remember);
+        const session = await loadSessionRecord(paths);
+        addDecisionRecord(session, {
+            kind: "approval",
+            agent: resolved.agent,
+            summary: `${decision === "allow" ? "Approved" : "Denied"} ${resolved.toolName}`,
+            detail: resolved.summary,
+            metadata: {
+                requestId: resolved.id,
+                remember,
+                toolName: resolved.toolName
+            }
+        });
+        await saveSessionRecord(paths, session);
+        await recordEvent(paths, session.id, "approval.resolved", {
+            requestId: resolved.id,
+            decision,
             remember,
-            toolName: request.toolName
-        }
-    });
-    await saveSessionRecord(paths, session);
-    await recordEvent(paths, session.id, "approval.resolved", {
-        requestId: request.id,
-        decision,
-        remember,
-        agent: request.agent,
-        toolName: request.toolName
-    });
+            agent: resolved.agent,
+            toolName: resolved.toolName
+        });
+    }
     console.log(`${decision === "allow" ? "Approved" : "Denied"} ${request.id}: ${request.summary}${remember ? " (remembered)" : ""}`);
 }
 async function commandEvents(cwd, args) {
     const { paths } = await requireSession(cwd);
     const limitArg = getFlag(args, "--limit");
     const limit = limitArg ? Number(limitArg) : 20;
-    const events = await readRecentEvents(paths, Number.isFinite(limit) ? limit : 20);
+    const rpcSnapshot = await tryRpcSnapshot(paths);
+    const events = rpcSnapshot ? await rpcRecentEvents(paths, Number.isFinite(limit) ? limit : 20) : await readRecentEvents(paths, Number.isFinite(limit) ? limit : 20);
     for (const event of events){
         console.log(`${event.timestamp} ${event.type} ${JSON.stringify(event.payload)}`);
     }
@@ -517,8 +616,12 @@ async function commandStop(cwd) {
         console.log(`Marked stale Kavi session ${session.id} as stopped`);
         return;
     }
-    await appendCommand(paths, "shutdown", {});
-    await recordEvent(paths, session.id, "daemon.stop_requested", {});
+    if (await pingRpc(paths)) {
+        await rpcShutdown(paths);
+    } else {
+        await appendCommand(paths, "shutdown", {});
+        await recordEvent(paths, session.id, "daemon.stop_requested", {});
+    }
     await waitForSession(paths, "stopped");
     console.log(`Stopped Kavi session ${session.id}`);
 }
@@ -618,6 +721,7 @@ async function commandHook(args) {
                 toolName: descriptor.toolName,
                 summary: descriptor.summary
             });
+            await notifyOperatorSurface(paths, "approval.auto_allowed");
             console.log(JSON.stringify({
                 continue: true,
                 suppressOutput: true,
@@ -642,6 +746,7 @@ async function commandHook(args) {
                 decision: rule.decision,
                 summary: descriptor.summary
             });
+            await notifyOperatorSurface(paths, "approval.auto_decided");
             console.log(JSON.stringify({
                 continue: true,
                 suppressOutput: true,
@@ -666,6 +771,7 @@ async function commandHook(args) {
             toolName: request.toolName,
             summary: request.summary
         });
+        await notifyOperatorSurface(paths, "approval.requested");
         const resolved = await waitForApprovalDecision(paths, request.id);
         const approved = resolved?.status === "approved";
         const denied = resolved?.status === "denied";
@@ -674,6 +780,7 @@ async function commandHook(args) {
             requestId: request.id,
             outcome: approved ? "approved" : denied ? "denied" : "expired"
         });
+        await notifyOperatorSurface(paths, "approval.completed");
         console.log(JSON.stringify({
             continue: true,
             suppressOutput: true,
@@ -687,6 +794,7 @@ async function commandHook(args) {
     }
     if (session) {
         await recordEvent(paths, session.id, "claude.hook", hookPayload);
+        await notifyOperatorSurface(paths, "claude.hook");
     }
     console.log(JSON.stringify({
         continue: true
@@ -731,6 +839,12 @@ async function main() {
         case "task-output":
             await commandTaskOutput(cwd, args);
             break;
+        case "decisions":
+            await commandDecisions(cwd, args);
+            break;
+        case "claims":
+            await commandClaims(cwd, args);
+            break;
         case "approvals":
             await commandApprovals(cwd, args);
             break;

package/dist/paths.js

@@ -23,7 +23,7 @@ export function resolveAppPaths(repoRoot) {
         approvalsFile: path.join(stateDir, "approvals.json"),
         commandsFile: path.join(runtimeDir, "commands.jsonl"),
         claudeSettingsFile: path.join(runtimeDir, "claude.settings.json"),
-        socketPath: path.join(runtimeDir, "kavid.sock"),
+        socketPath: path.join(homeStateDir, "sockets", `${safeRepoId}.sock`),
         homeConfigDir,
         homeConfigFile: path.join(homeConfigDir, "config.toml"),
         homeApprovalRulesFile: path.join(homeConfigDir, "approval-rules.json"),

package/dist/rpc.js

@@ -0,0 +1,226 @@
+import net from "node:net";
+const RPC_TIMEOUT_MS = 4_000;
+function randomId() {
+    return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function asObject(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+export async function sendRpcRequest(paths, method, params = {}) {
+    return await new Promise((resolve, reject)=>{
+        const socket = net.createConnection(paths.socketPath);
+        const requestId = randomId();
+        let buffer = "";
+        let settled = false;
+        const finish = (callback)=>{
+            if (settled) {
+                return;
+            }
+            settled = true;
+            socket.setTimeout(0);
+            socket.end();
+            callback();
+        };
+        socket.setEncoding("utf8");
+        socket.setTimeout(RPC_TIMEOUT_MS, ()=>{
+            finish(()=>reject(new Error(`RPC ${method} timed out after ${RPC_TIMEOUT_MS}ms.`)));
+        });
+        socket.on("connect", ()=>{
+            const payload = {
+                id: requestId,
+                method,
+                params
+            };
+            socket.write(`${JSON.stringify(payload)}\n`);
+        });
+        socket.on("data", (chunk)=>{
+            buffer += chunk;
+            while(true){
+                const newlineIndex = buffer.indexOf("\n");
+                if (newlineIndex === -1) {
+                    return;
+                }
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                if (!line) {
+                    continue;
+                }
+                let response;
+                try {
+                    response = JSON.parse(line);
+                } catch (error) {
+                    finish(()=>{
+                        reject(new Error(error instanceof Error ? error.message : `Unable to parse RPC response for ${method}.`));
+                    });
+                    return;
+                }
+                if (response.id !== requestId) {
+                    continue;
+                }
+                if (response.error) {
+                    finish(()=>reject(new Error(response.error?.message ?? `${method} failed.`)));
+                    return;
+                }
+                finish(()=>resolve(response.result));
+                return;
+            }
+        });
+        socket.on("error", (error)=>{
+            finish(()=>reject(error));
+        });
+        socket.on("end", ()=>{
+            if (!settled) {
+                finish(()=>reject(new Error(`Socket closed before completing ${method}.`)));
+            }
+        });
+    });
+}
+export async function pingRpc(paths) {
+    try {
+        await sendRpcRequest(paths, "ping");
+        return true;
+    } catch  {
+        return false;
+    }
+}
+export async function readSnapshot(paths) {
+    return await sendRpcRequest(paths, "snapshot");
+}
+export async function rpcKickoff(paths, prompt) {
+    await sendRpcRequest(paths, "kickoff", {
+        prompt
+    });
+}
+export async function rpcEnqueueTask(paths, params) {
+    await sendRpcRequest(paths, "enqueueTask", {
+        owner: params.owner,
+        prompt: params.prompt,
+        routeReason: params.routeReason,
+        claimedPaths: params.claimedPaths,
+        routeStrategy: params.routeStrategy,
+        routeConfidence: params.routeConfidence
+    });
+}
+export async function rpcResolveApproval(paths, params) {
+    await sendRpcRequest(paths, "resolveApproval", params);
+}
+export async function rpcShutdown(paths) {
+    await sendRpcRequest(paths, "shutdown");
+}
+export async function rpcNotifyExternalUpdate(paths, reason) {
+    await sendRpcRequest(paths, "notifyExternalUpdate", {
+        reason
+    });
+}
+export async function rpcTaskArtifact(paths, taskId) {
+    return await sendRpcRequest(paths, "taskArtifact", {
+        taskId
+    });
+}
+export async function rpcRecentEvents(paths, limit) {
+    return await sendRpcRequest(paths, "events", {
+        limit
+    });
+}
+export async function rpcWorktreeDiff(paths, agent, filePath) {
+    return await sendRpcRequest(paths, "worktreeDiff", {
+        agent,
+        filePath
+    });
+}
+export function subscribeSnapshotRpc(paths, handlers) {
+    const socket = net.createConnection(paths.socketPath);
+    const requestId = randomId();
+    let buffer = "";
+    let closed = false;
+    let connectedResolver = null;
+    let connectedRejecter = null;
+    const connected = new Promise((resolve, reject)=>{
+        connectedResolver = resolve;
+        connectedRejecter = reject;
+    });
+    const finishWithError = (error)=>{
+        handlers.onError?.(error);
+        if (connectedRejecter) {
+            connectedRejecter(error);
+            connectedRejecter = null;
+            connectedResolver = null;
+        }
+    };
+    socket.setEncoding("utf8");
+    socket.setTimeout(RPC_TIMEOUT_MS, ()=>{
+        finishWithError(new Error(`Subscription timed out after ${RPC_TIMEOUT_MS}ms.`));
+        socket.end();
+    });
+    socket.on("connect", ()=>{
+        const payload = {
+            id: requestId,
+            method: "subscribe"
+        };
+        socket.write(`${JSON.stringify(payload)}\n`);
+    });
+    socket.on("data", (chunk)=>{
+        buffer += chunk;
+        while(true){
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            let message;
+            try {
+                message = JSON.parse(line);
+            } catch (error) {
+                finishWithError(new Error(error instanceof Error ? error.message : "Unable to parse snapshot subscription payload."));
+                socket.end();
+                return;
+            }
+            if ("id" in message && message.id === requestId) {
+                if (message.error) {
+                    finishWithError(new Error(message.error.message));
+                    socket.end();
+                    return;
+                }
+                socket.setTimeout(0);
+                connectedResolver?.();
+                connectedResolver = null;
+                connectedRejecter = null;
+                handlers.onSnapshot({
+                    reason: "subscribe",
+                    snapshot: message.result
+                });
+                continue;
+            }
+            if ("method" in message && message.method === "snapshot.updated") {
+                handlers.onSnapshot(message.params);
+            }
+        }
+    });
+    socket.on("error", (error)=>{
+        if (!closed) {
+            finishWithError(error instanceof Error ? error : new Error(String(error)));
+        }
+    });
+    socket.on("close", ()=>{
+        if (!closed) {
+            handlers.onDisconnect?.();
+        }
+    });
+    return {
+        connected,
+        close: ()=>{
+            closed = true;
+            socket.end();
+        }
+    };
+}
+export function parseRpcParams(value) {
+    return asObject(value);
+}
+
+
+//# sourceURL=rpc.ts

package/dist/task-artifacts.js

@@ -4,6 +4,14 @@ import { ensureDir, fileExists, readJson, writeJson } from "./fs.js";
 function artifactPath(paths, taskId) {
     return path.join(paths.runsDir, `${taskId}.json`);
 }
+function normalizeArtifact(artifact) {
+    return {
+        ...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)) : []
+    };
+}
 export async function saveTaskArtifact(paths, artifact) {
     await ensureDir(paths.runsDir);
     await writeJson(artifactPath(paths, artifact.taskId), artifact);
@@ -13,7 +21,7 @@ export async function loadTaskArtifact(paths, taskId) {
     if (!await fileExists(filePath)) {
         return null;
     }
-    return readJson(filePath);
+    return normalizeArtifact(await readJson(filePath));
 }
 export async function listTaskArtifacts(paths) {
     if (!await fileExists(paths.runsDir)) {
@@ -28,7 +36,7 @@ export async function listTaskArtifacts(paths) {
             continue;
         }
         const artifact = await readJson(path.join(paths.runsDir, entry.name));
-        artifacts.push(artifact);
+        artifacts.push(normalizeArtifact(artifact));
     }
     return artifacts.sort((left, right)=>left.finishedAt.localeCompare(right.finishedAt));
 }