@mandipadk7/kavi 0.1.0 → 0.1.2

package/dist/main.js

@@ -6,13 +6,15 @@ 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 { runDoctor } from "./doctor.js";
 import { writeJson } from "./fs.js";
-import { createGitignoreEntries, detectRepoRoot, ensureWorktrees, getHeadCommit, landBranches, resolveTargetBranch } from "./git.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 { routePrompt } from "./router.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 { attachTui } from "./tui.js";
@@ -67,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]",
@@ -95,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") {
@@ -143,14 +147,13 @@ async function startOrAttachSession(cwd, goal) {
     await ensureProjectScaffold(paths);
     await createGitignoreEntries(repoRoot);
     await ensureHomeConfig(paths);
+    await ensureStartupReady(repoRoot, paths);
     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;
             }
@@ -164,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);
@@ -180,6 +183,23 @@ async function startOrAttachSession(cwd, goal) {
     await waitForSession(paths);
     return rpcEndpoint;
 }
+async function ensureStartupReady(repoRoot, paths) {
+    const checks = await runDoctor(repoRoot, paths);
+    const required = new Set([
+        "node",
+        "codex",
+        "claude",
+        "git-worktree",
+        "codex-app-server",
+        "codex-auth-file"
+    ]);
+    const failures = checks.filter((check)=>required.has(check.name) && !check.ok);
+    if (failures.length === 0) {
+        return;
+    }
+    const details = failures.map((check)=>`${check.name}: ${check.detail}`).join("\n");
+    throw new Error(`Kavi startup blocked by failing readiness checks.\n${details}\nRun "kavi doctor" for the full report.`);
+}
 async function requireSession(cwd) {
     const repoRoot = await detectRepoRoot(cwd);
     const paths = resolveAppPaths(repoRoot);
@@ -191,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);
@@ -219,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: {
@@ -243,6 +280,12 @@ async function commandStatus(cwd, args) {
         approvalCounts: {
             pending: pendingApprovals.length
         },
+        decisionCounts: {
+            total: session.decisions.length
+        },
+        pathClaimCounts: {
+            active: session.pathClaims.filter((claim)=>claim.status === "active").length
+        },
         worktrees: session.worktrees
     };
     if (args.includes("--json")) {
@@ -252,12 +295,15 @@ 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)`}`);
     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(`Decisions: total=${payload.decisionCounts.total}`);
+    console.log(`Path claims: active=${payload.pathClaimCounts.active}`);
     for (const worktree of payload.worktrees){
         console.log(`- ${worktree.agent}: ${worktree.path}`);
     }
@@ -278,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,
@@ -298,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}`);
@@ -305,26 +353,52 @@ 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) {
         throw new Error("A task prompt is required. Example: kavi task --agent auto \"Build auth route\"");
     }
-    const owner = requestedAgent === "codex" || requestedAgent === "claude" ? requestedAgent : routePrompt(prompt, session.config);
-    await appendCommand(paths, "enqueue", {
-        owner,
-        prompt
-    });
+    const routeDecision = requestedAgent === "codex" || requestedAgent === "claude" ? {
+        owner: requestedAgent,
+        strategy: "manual",
+        confidence: 1,
+        reason: `User explicitly assigned the task to ${requestedAgent}.`,
+        claimedPaths: extractPromptPathHints(prompt)
+    } : await routeTask(prompt, session, paths);
+    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,
-        prompt
+        owner: routeDecision.owner,
+        prompt,
+        strategy: routeDecision.strategy,
+        confidence: routeDecision.confidence,
+        claimedPaths: routeDecision.claimedPaths
     });
-    console.log(`Queued task for ${owner}: ${prompt}`);
+    console.log(`Queued task for ${routeDecision.owner}: ${prompt}\nRoute: ${routeDecision.strategy} (${routeDecision.confidence.toFixed(2)}) ${routeDecision.reason}`);
 }
 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,
@@ -338,6 +412,8 @@ async function commandTasks(cwd, args) {
             createdAt: task.createdAt,
             updatedAt: task.updatedAt,
             summary: task.summary,
+            routeReason: task.routeReason,
+            claimedPaths: task.claimedPaths,
             hasArtifact: artifactMap.has(task.id)
         }));
     if (args.includes("--json")) {
@@ -348,6 +424,8 @@ 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(`  paths: ${task.claimedPaths.join(", ") || "-"}`);
         console.log(`  summary: ${task.summary ?? "-"}`);
     }
 }
@@ -367,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}.`);
     }
@@ -386,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")) {
@@ -425,28 +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);
-    await recordEvent(paths, session.id, "approval.resolved", {
-        requestId: request.id,
-        decision,
-        remember,
-        agent: request.agent,
-        toolName: request.toolName
-    });
+    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,
+            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)}`);
     }
@@ -461,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}`);
 }
@@ -471,6 +630,51 @@ async function commandLand(cwd) {
     const paths = resolveAppPaths(repoRoot);
     const session = await loadSessionRecord(paths);
     const targetBranch = await resolveTargetBranch(repoRoot, session.config.baseBranch);
+    const overlappingPaths = await findOverlappingWorktreePaths(session.worktrees, session.baseCommit);
+    if (overlappingPaths.length > 0) {
+        const existing = session.tasks.find((task)=>task.status === "pending" && task.title === "Resolve integration overlap");
+        if (!existing) {
+            const taskId = `integration-${Date.now()}`;
+            session.tasks.push(buildAdHocTask("codex", [
+                "Resolve overlapping worktree changes before landing.",
+                `Target branch: ${targetBranch}`,
+                "Overlapping paths:",
+                ...overlappingPaths.map((item)=>`- ${item}`)
+            ].join("\n"), taskId, {
+                title: "Resolve integration overlap",
+                routeReason: "Created by kavi land because multiple agents changed the same paths.",
+                claimedPaths: overlappingPaths
+            }));
+            upsertPathClaim(session, {
+                taskId,
+                agent: "codex",
+                source: "integration",
+                paths: overlappingPaths,
+                note: "Integration overlap detected during landing."
+            });
+        }
+        addDecisionRecord(session, {
+            kind: "integration",
+            agent: "codex",
+            summary: "Landing blocked by overlapping worktree paths",
+            detail: overlappingPaths.join(", "),
+            metadata: {
+                targetBranch,
+                overlappingPaths
+            }
+        });
+        await saveSessionRecord(paths, session);
+        await recordEvent(paths, session.id, "land.overlap_detected", {
+            targetBranch,
+            overlappingPaths
+        });
+        console.log("Landing blocked because both agent worktrees changed overlapping paths.");
+        console.log("Queued integration task for codex:");
+        for (const filePath of overlappingPaths){
+            console.log(`- ${filePath}`);
+        }
+        return;
+    }
     const result = await landBranches(repoRoot, targetBranch, session.worktrees, session.config.validationCommand, session.id, paths.integrationRoot);
     await recordEvent(paths, session.id, "land.completed", {
         targetBranch,
@@ -517,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,
@@ -541,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,
@@ -565,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";
@@ -573,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,
@@ -586,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
@@ -630,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/prompts.js

@@ -0,0 +1,13 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileExists } from "./fs.js";
+export async function loadAgentPrompt(paths, agent) {
+    const promptPath = path.join(paths.promptsDir, `${agent}.md`);
+    if (!await fileExists(promptPath)) {
+        return "";
+    }
+    return (await fs.readFile(promptPath, "utf8")).trim();
+}
+
+
+//# sourceURL=prompts.ts