@nanhara/hara 0.112.4 → 0.112.5

package/dist/index.js

@@ -65,7 +65,7 @@ import { getEmbedder } from "./search/embed.js";
 import { collectRepoChunks, collectDirChunks, buildIndex, indexPath, indexExists } from "./search/semindex.js";
 import { searchHybrid } from "./search/hybrid.js";
 import { expandMentions, fileCandidates, isSlashCommand, inlineLeadingPath } from "./context/mentions.js";
-import { newSessionId, shortId, resolveSessionId, saveSession, loadSession, listSessions, latestForCwd, titleFrom, slugify, } from "./session/store.js";
+import { newSessionId, shortId, resolveSessionId, saveSession, loadSession, acquireSessionLock, releaseSessionLock, listSessions, latestForCwd, titleFrom, slugify, } from "./session/store.js";
 import { setSessionForceModel, isSessionForceModel, effectiveRoleModel } from "./session/session-model.js";
 import { loadRoles, scaffoldRoles, subagentToolFilter } from "./org/roles.js";
 import { loadSkillIndex, loadSkillBody, scaffoldSkills, globalSkillsDir } from "./skills/skills.js";
@@ -2392,6 +2392,16 @@ program.action(async (opts) => {
         createdAt: new Date().toISOString(),
         updatedAt: "",
     };
+    // Single-writer guard: two hara processes on the SAME session race writes to its append-only history and
+    // corrupt it. Lock it here (a brand-new session's id is unique, so this only ever blocks a DOUBLE-resume
+    // of a session already open elsewhere). Released on exit.
+    const lock = acquireSessionLock(meta.id);
+    if (!lock.ok) {
+        out(c.red(`Session ${shortId(meta.id)} is already open in another hara process (pid ${lock.pid}).`) +
+            c.dim(` Resuming the same session twice races writes and can corrupt its history. Close that one, or run \`hara\` for a new session. (Override: rm ~/.hara/sessions/${meta.id}.lock)\n`));
+        process.exit(1);
+    }
+    process.on("exit", () => releaseSessionLock(meta.id));
     // Per-session model precedence on resume:
     //   1. --model flag (already applied to cfg.model up-top) → wins and is written back to meta.model.
     //   2. resumed meta.model → restored into cfg.model (the user's last /model choice).

package/dist/session/store.js

@@ -1,7 +1,7 @@
 // Session persistence — conversations saved as JSON under ~/.hara/sessions, resumable.
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import { randomUUID } from "node:crypto";
 function sessionsDir() {
     const d = join(homedir(), ".hara", "sessions");
@@ -9,6 +9,54 @@ function sessionsDir() {
     return d;
 }
 const sessionFile = (id) => join(sessionsDir(), `${id}.json`);
+const lockFile = (id) => join(sessionsDir(), `${id}.lock`);
+/** Is a process with this pid alive? `process.kill(pid, 0)` sends no signal — it just probes: throws
+ *  ESRCH if dead, EPERM if alive-but-not-ours (still alive). Best-effort across platforms. */
+function pidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e?.code === "EPERM";
+    }
+}
+/** Take an exclusive lock on a session so two hara processes can't resume the SAME session and corrupt
+ *  its append-only history by racing writes. Returns `{ ok: true }` if acquired (or the previous holder
+ *  is dead → we take over), or `{ ok: false, pid }` if a LIVE process already holds it. Best-effort: any
+ *  filesystem hiccup resolves to `ok:true` so a lock problem never blocks the user. Pair with
+ *  `releaseSessionLock` on exit. */
+export function acquireSessionLock(id) {
+    const f = lockFile(id);
+    try {
+        if (existsSync(f)) {
+            const held = JSON.parse(readFileSync(f, "utf8"));
+            if (typeof held.pid === "number" && held.pid !== process.pid && pidAlive(held.pid)) {
+                return { ok: false, pid: held.pid };
+            }
+            // stale (dead pid) or already ours → fall through and (re)claim it
+        }
+        writeFileSync(f, JSON.stringify({ pid: process.pid, startedAt: Date.now() }));
+        return { ok: true };
+    }
+    catch {
+        return { ok: true };
+    }
+}
+/** Release a session lock we hold (only removes it if the pid matches ours — never steals another's). */
+export function releaseSessionLock(id) {
+    try {
+        const f = lockFile(id);
+        if (!existsSync(f))
+            return;
+        const held = JSON.parse(readFileSync(f, "utf8"));
+        if (held?.pid === process.pid)
+            rmSync(f);
+    }
+    catch {
+        /* best-effort */
+    }
+}
 /** A full UUID per session (the stable identity). */
 export const newSessionId = () => randomUUID();
 /** First segment of the UUID — a compact label for the status bar / `/sessions`. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nanhara/hara",
-  "version": "0.112.4",
+  "version": "0.112.5",
   "description": "hara — a coding agent CLI that runs like an engineering org.",
   "bin": {
     "hara": "dist/index.js"