pi-hashline-edit-pro 4.2.9 → 4.2.10

package/README.md

@@ -199,7 +199,7 @@ The table is curated for tokenizers, not for humans. Every anchor is the concate
 
 Each line also carries a content checksum. The line is canonicalized (carriage returns stripped, trailing whitespace trimmed) and hashed with [xxhash-wasm](https://github.com/jungomi/xxhash-wasm). The canonicalization keeps the checksum stable across editor-save cycles that add or remove trailing whitespace. A line over 500 bytes is hashed from its first 500 bytes.
 
-Allocated anchors live in a persistent per-file snapshot (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) keyed by content checksum, so resume-after-restart and cross-session edits reuse ownership instead of minting duplicates. Each session also appends an ownership log (`allocate`/`free`/`clear` events) to a sidecar file under `~/.config/pi-hashline-edit-pro/sessions/`; the fold of that log is the session's source of truth, sidecars whose session file is gone are garbage-collected at startup, and the in-memory ownership of a session is released when that session shuts down and rebuilt from its sidecar on next use.
+Allocated anchors live in a persistent per-file snapshot (`~/.config/pi-hashline-edit-pro/hash-store.sqlite`) keyed by content checksum, so resume-after-restart and cross-session edits reuse ownership instead of minting duplicates. Each session also appends an ownership log (`allocate`/`free`/`clear` events) to a sidecar file under `~/.config/pi-hashline-edit-pro/sessions/`; the fold of that log is the session's source of truth, sidecars whose session file is gone are garbage-collected at startup (never the sidecar of a session that is currently loaded in this process), and the in-memory ownership of a session is released when that session shuts down and rebuilt from its sidecar on next use.
 
 When a range is edited, the mapping between old and new content is computed per span: lines whose content is unchanged keep their allocated anchors, anchors of removed lines are freed, and every genuinely new line is minted a fresh anchor. Anchors are never assigned by matching content; only positional survival across an edit preserves one.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-hashline-edit-pro",
-  "version": "4.2.9",
+  "version": "4.2.10",
   "type": "module",
   "description": "Hash-anchored read/replace/insert/grep tools for pi-coding-agent. Every line gets a unique 4-char tokenizer-friendly anchor that stays stable across edits; stale or ambiguous anchors are rejected, never fuzzy-matched. Undo persists across restarts.",
   "main": "index.ts",

package/src/anchor-registry.ts

@@ -1,5 +1,5 @@
 import { chmod, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { appendFileSync, chmodSync } from "node:fs";
+import { appendFileSync, chmodSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -163,6 +163,7 @@ export const SIDECAR_HEADER_BYTES = 64 * 1024;
 const SIDECAR_HEADER_CHUNK = 4096;
 let currentKey: string | undefined;
 const sidecarByKey = new Map<string, string>();
+const sessionFileByKey = new Map<string, string>();
 const pendingInits = new Map<string, Promise<void>>();
 const loadTokens = new Map<string, object>();
 const registries = new Map<string, SessionState>();
@@ -368,6 +369,7 @@ async function ensureRegistryForKey(key: string, sessionFile: string | undefined
       registries.set(key, newSessionState(key));
       return;
     }
+    sessionFileByKey.set(key, sessionFile);
     await loadRegistryState(key, sessionFile, token);
   })();
   pendingInits.set(key, promise);
@@ -423,12 +425,27 @@ function current(): SessionState | undefined {
   return registries.get(key);
 }
 
+function sidecarNeedsSessionRecord(sidecar: string): boolean {
+  try {
+    return statSync(sidecar).size === 0;
+  } catch {
+    return true;
+  }
+}
+
+function ensureSidecarSessionRecord(key: string, sidecar: string): void {
+  const sessionFile = sessionFileByKey.get(key);
+  if (sessionFile === undefined || !sidecarNeedsSessionRecord(sidecar)) return;
+  appendEvent({ kind: "session", sessionFile } satisfies RegistryEvent);
+}
+
 function appendEvent(event: RegistryEvent): void {
   const key = activeKey();
   if (!key) return;
   const sidecar = sidecarByKey.get(key);
   if (!sidecar) return;
   try {
+    if (event.kind !== "session") ensureSidecarSessionRecord(key, sidecar);
     appendFileSync(sidecar, JSON.stringify(event) + "\n", "utf-8");
     if (process.platform !== "win32") {
       try { chmodSync(sidecar, 0o600); } catch (error) { if (errCode(error) !== "ENOENT") console.error("Failed to secure anchor registry sidecar:", error); }
@@ -880,6 +897,7 @@ export function adoptAnchors(path: string, entries: Map<string, string>): void {
 export function resetRegistryForTests(): void {
   currentKey = undefined;
   sidecarByKey.clear();
+  sessionFileByKey.clear();
   pendingInits.clear();
   loadTokens.clear();
   registries.clear();
@@ -924,9 +942,17 @@ export function releaseRegistrySession(key: string): void {
   if (currentKey === key) currentKey = undefined;
   pendingInits.delete(key);
   sidecarByKey.delete(key);
+  sessionFileByKey.delete(key);
   registries.delete(key);
 }
 
+function isClaimedSidecar(sidecar: string): boolean {
+  for (const claimed of sidecarByKey.values()) {
+    if (claimed === sidecar) return true;
+  }
+  return false;
+}
+
 export async function gcRegistrySidecars(): Promise<void> {
   let names: string[];
   try {
@@ -948,6 +974,7 @@ export async function gcRegistrySidecars(): Promise<void> {
     }
     if (!name.endsWith(SIDECAR_SUFFIX)) continue;
     const sidecar = join(sessionClaimsDir(), name);
+    if (isClaimedSidecar(sidecar)) continue;
     try {
       const sessionFile = await readSidecarSessionFile(sidecar);
       if (sessionFile === undefined) continue;