@code-yeongyu/senpi 2026.10.23-1 → 2026.10.24-1

package/dist/core/session-rebind.js

@@ -1,14 +1,14 @@
-import { cpSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from "node:fs";
-import { readFile, writeFile } from "node:fs/promises";
+import { cp, mkdir, open, readdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
 import { normalizePath, resolvePath } from "../utils/paths.js";
 import { compareRepositoryIdentities, parseRepositoryIdentity, REPOSITORY_IDENTITY_ENTRY_TYPE, readRepositoryIdentity, } from "./repository-identity.js";
 import { withSessionMoveLock } from "./session-holders.js";
-import { getDefaultSessionDir, loadEntriesFromFile } from "./session-manager.js";
+import { getDefaultSessionDir, loadEntriesFromFileAsync } from "./session-manager.js";
 import { encodedSessionId } from "./session-sidecar-store.js";
-export function readRecordedRepositoryIdentity(sessionFile) {
+import { pathExists } from "./tools/path-utils.js";
+export async function readRecordedRepositoryIdentity(sessionFile) {
     let recorded;
-    for (const entry of loadEntriesFromFile(sessionFile)) {
+    for (const entry of await loadEntriesFromFileAsync(sessionFile)) {
         if (entry.type === "custom" && entry.customType === REPOSITORY_IDENTITY_ENTRY_TYPE) {
             recorded = parseRepositoryIdentity(entry.data) ?? recorded;
         }
@@ -23,12 +23,12 @@ export function readRecordedRepositoryIdentity(sessionFile) {
 export async function classifySessionRepository(sessionFile, sessionCwd, cwd, read = readRepositoryIdentity) {
     const [current, live] = await Promise.all([
         read(cwd),
-        existsSync(sessionCwd) ? read(sessionCwd) : Promise.resolve(undefined),
+        pathExists(sessionCwd).then((exists) => (exists ? read(sessionCwd) : undefined)),
     ]);
-    return compareRepositoryIdentities(live ?? readRecordedRepositoryIdentity(sessionFile), current);
+    return compareRepositoryIdentities(live ?? (await readRecordedRepositoryIdentity(sessionFile)), current);
 }
 export async function readSessionCwd(sessionFile) {
-    const { cwd } = (await readHeaderLine(resolvePath(sessionFile))).header;
+    const { cwd } = await readHeader(resolvePath(sessionFile));
     return typeof cwd === "string" && cwd !== "" ? cwd : undefined;
 }
 /**
@@ -46,7 +46,7 @@ export async function rebindSessionFile(sourcePath, targetCwd, sessionDir, optio
     const cwd = resolvePath(targetCwd);
     const targetDir = sessionDir ? normalizePath(sessionDir) : getDefaultSessionDir(cwd);
     const target = join(targetDir, basename(source));
-    if (target !== source && !existsSync(source) && existsSync(target))
+    if (target !== source && (await movedAlready(source, target)))
         return target;
     const header = await readHeaderBeforeLock(source, target);
     if (header === undefined)
@@ -60,36 +60,66 @@ export async function rebindSessionFile(sourcePath, targetCwd, sessionDir, optio
 // missing source next to an existing target means the move is already done (`undefined`).
 async function readHeaderBeforeLock(source, target) {
     try {
-        return (await readHeaderLine(source)).header;
+        return await readHeader(source);
     }
     catch (error) {
-        if (error.code === "ENOENT" && target !== source && existsSync(target))
+        if (error.code === "ENOENT" && target !== source && (await pathExists(target)))
             return undefined;
         throw error;
     }
 }
 async function moveSessionFile(source, target, cwd) {
-    if (target !== source && !existsSync(source) && existsSync(target))
+    if (target !== source && (await movedAlready(source, target)))
         return target;
     const { header, rest } = await readHeaderLine(source);
-    if (target !== source && existsSync(target)) {
+    if (target !== source && (await pathExists(target))) {
         throw new Error(`Cannot rebind session: ${target} already exists`);
     }
     const targetDir = dirname(target);
-    mkdirSync(targetDir, { recursive: true });
+    await mkdir(targetDir, { recursive: true });
     const temp = join(targetDir, `.${basename(source)}.rebind-${process.pid}.tmp`);
     await writeFile(temp, `${JSON.stringify({ ...header, cwd })}\n${rest}`, { flag: "wx" });
     if (target !== source)
-        moveSessionSidecars(dirname(source), targetDir, header.id);
-    renameSync(temp, target);
+        await moveSessionSidecars(dirname(source), targetDir, header.id);
+    await rename(temp, target);
     if (target !== source)
-        rmSync(source, { force: true });
+        await rm(source, { force: true });
     return target;
 }
+/** A concurrent rebind writes the target before it removes the source: no source next to a target means done. */
+async function movedAlready(source, target) {
+    return !(await pathExists(source)) && (await pathExists(target));
+}
 async function readHeaderLine(sessionFile) {
     const content = await readFile(sessionFile, "utf8");
     const newline = content.indexOf("\n");
     const firstLine = newline === -1 ? content : content.slice(0, newline);
+    return { header: parseHeader(firstLine, sessionFile), rest: newline === -1 ? "" : content.slice(newline + 1) };
+}
+const HEADER_CHUNK_BYTES = 64 * 1024;
+/** The header alone: reads up to the first newline, never the transcript after it. */
+async function readHeader(sessionFile) {
+    const handle = await open(sessionFile, "r");
+    try {
+        const chunks = [];
+        const buffer = Buffer.allocUnsafe(HEADER_CHUNK_BYTES);
+        while (true) {
+            const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+            if (bytesRead === 0)
+                break;
+            const chunk = buffer.subarray(0, bytesRead);
+            const newline = chunk.indexOf(0x0a);
+            chunks.push(Buffer.from(newline === -1 ? chunk : chunk.subarray(0, newline)));
+            if (newline !== -1)
+                break;
+        }
+        return parseHeader(Buffer.concat(chunks).toString("utf8"), sessionFile);
+    }
+    finally {
+        await handle.close();
+    }
+}
+function parseHeader(firstLine, sessionFile) {
     let parsed;
     try {
         parsed = JSON.parse(firstLine);
@@ -100,7 +130,7 @@ async function readHeaderLine(sessionFile) {
     if (!isSessionHeader(parsed)) {
         throw new Error(`Cannot rebind session: ${sessionFile} does not start with a session header`);
     }
-    return { header: parsed, rest: newline === -1 ? "" : content.slice(newline + 1) };
+    return parsed;
 }
 function isSessionHeader(value) {
     return (typeof value === "object" &&
@@ -110,34 +140,34 @@ function isSessionHeader(value) {
 }
 // Per-session extension state lives at `<sessionDir>/extensions/<extension>/<encoded id>.json`
 // (goal, loop, terminal monitors); without it a rebound session would lose its goal and monitors.
-function moveSessionSidecars(fromDir, toDir, sessionId) {
+async function moveSessionSidecars(fromDir, toDir, sessionId) {
     const extensionsDir = join(fromDir, "extensions");
     const sidecarName = `${encodedSessionId(sessionId)}.json`;
-    if (existsSync(extensionsDir)) {
-        for (const extension of readdirSync(extensionsDir, { withFileTypes: true })) {
+    if (await pathExists(extensionsDir)) {
+        for (const extension of await readdir(extensionsDir, { withFileTypes: true })) {
             if (!extension.isDirectory())
                 continue;
             const from = join(extensionsDir, extension.name, sidecarName);
-            if (existsSync(from))
-                movePath(from, join(toDir, "extensions", extension.name, sidecarName));
+            if (await pathExists(from))
+                await movePath(from, join(toDir, "extensions", extension.name, sidecarName));
         }
     }
     const blobs = join(fromDir, "resident-blobs", sessionId);
-    if (existsSync(blobs))
-        movePath(blobs, join(toDir, "resident-blobs", sessionId));
+    if (await pathExists(blobs))
+        await movePath(blobs, join(toDir, "resident-blobs", sessionId));
 }
-function movePath(from, to) {
-    if (existsSync(to))
+async function movePath(from, to) {
+    if (await pathExists(to))
         return;
-    mkdirSync(dirname(to), { recursive: true });
+    await mkdir(dirname(to), { recursive: true });
     try {
-        renameSync(from, to);
+        await rename(from, to);
     }
     catch (error) {
         if (error.code !== "EXDEV")
             throw error;
-        cpSync(from, to, { recursive: true });
-        rmSync(from, { recursive: true, force: true });
+        await cp(from, to, { recursive: true });
+        await rm(from, { recursive: true, force: true });
     }
 }
 //# sourceMappingURL=session-rebind.js.map

package/dist/modes/rpc/session-move-commands.js

@@ -4,7 +4,7 @@
  * outgoing bundles and the session folder for a working directory) and maps refusals to wire codes.
  */
 import { isAbsolute, join } from "node:path";
-import { getDefaultSessionDir, loadEntriesFromFile } from "../../core/session-manager.js";
+import { getDefaultSessionDir, loadEntriesFromFileAsync } from "../../core/session-manager.js";
 import { parseMoveId } from "../../core/session-move/bundle.js";
 import { exportSessionForMove } from "../../core/session-move/export.js";
 import { sealedOutgoingStateDir } from "../../core/session-move/extension-state.js";
@@ -13,7 +13,7 @@ import { answerMoveStatus, importMovedSession } from "../../core/session-move/im
 import { MoveLedger, parseMoveStatus } from "../../core/session-move/move-ledger.js";
 import { headerSessionId, sessionOwnership } from "../../core/session-move/ownership.js";
 import { revokeImportedMove } from "../../core/session-move/revoke.js";
-import { realSessionPath } from "../../core/session-move/session-lock.js";
+import { orderedRealPath, realSessionPath } from "../../core/session-move/session-lock.js";
 import { normalizePath, resolvePath } from "../../utils/paths.js";
 import { RPC_ERROR_INVALID_MOVE_REQUEST, RPC_ERROR_MOVE_FAILED, RPC_ERROR_MOVE_NOT_RELEASED, RPC_ERROR_SESSION_OPEN_HERE, } from "./session-move-wire.js";
 /** Refusal codes the move core throws (`error.code`), passed through to the wire as they are. */
@@ -113,7 +113,7 @@ async function run(parsed, port, ledger, outgoing) {
         case "status":
             return answerMoveStatus(ledger, parsed.moveId, parsed.sessionPath);
         case "export": {
-            const sessionFile = realSessionPath(parsed.sessionPath);
+            const sessionFile = await orderedRealPath(parsed.sessionPath);
             const bundleDir = outgoing(parsed.moveId);
             const manifest = await exportSessionForMove({
                 sessionFile,
@@ -122,9 +122,9 @@ async function run(parsed, port, ledger, outgoing) {
                 droppedUserMessages: parsed.dropped,
                 bundleDir,
                 extensionStateDir: () => sealedOutgoingStateDir(sessionFile, parsed.moveId),
-                guard: () => {
-                    refuseOpenHere(port, sessionFile, "This session is open on this host. Release it with release_session reason move and this moveId first.");
-                    refuseUnlessSealedFor(sessionFile, parsed.moveId);
+                guard: async () => {
+                    await refuseOpenHere(port, sessionFile, "This session is open on this host. Release it with release_session reason move and this moveId first.");
+                    await refuseUnlessSealedFor(sessionFile, parsed.moveId);
                 },
                 // Again inside the cross-process lock: a finish from another generation may have reclaimed it meanwhile.
                 lockedGuard: () => refuseUnlessSealedFor(sessionFile, parsed.moveId),
@@ -146,13 +146,13 @@ async function run(parsed, port, ledger, outgoing) {
                 sessionDir,
                 from: parsed.from,
             });
-            const sessionId = headerSessionId(loadEntriesFromFile(sessionFile));
+            const sessionId = headerSessionId(await loadEntriesFromFileAsync(sessionFile));
             if (sessionId === undefined)
                 throw new Error(`The imported session at ${sessionFile} has no id in its header.`);
             return { session_id: sessionId, session_path: sessionFile };
         }
         case "finish": {
-            const sessionFile = realSessionPath(parsed.sessionPath);
+            const sessionFile = await orderedRealPath(parsed.sessionPath);
             await finishMove({
                 sessionFile,
                 bundleDir: outgoing(parsed.moveId),
@@ -163,7 +163,7 @@ async function run(parsed, port, ledger, outgoing) {
             return ownershipOf(sessionFile);
         }
         case "revoke": {
-            const sessionFile = realSessionPath(parsed.sessionPath);
+            const sessionFile = await orderedRealPath(parsed.sessionPath);
             await revokeImportedMove({
                 sessionFile,
                 moveId: parsed.moveId,
@@ -174,8 +174,8 @@ async function run(parsed, port, ledger, outgoing) {
         }
     }
 }
-function ownershipOf(sessionFile) {
-    const ownership = sessionOwnership(loadEntriesFromFile(sessionFile));
+async function ownershipOf(sessionFile) {
+    const ownership = sessionOwnership(await loadEntriesFromFileAsync(sessionFile));
     return { ownership: ownership.writable ? "writable" : ownership.state };
 }
 class MoveRefusal extends Error {
@@ -185,13 +185,14 @@ class MoveRefusal extends Error {
         this.code = code;
     }
 }
-function refuseUnlessSealedFor(sessionFile, moveId) {
-    const ownership = sessionOwnership(loadEntriesFromFile(sessionFile));
+async function refuseUnlessSealedFor(sessionFile, moveId) {
+    const ownership = sessionOwnership(await loadEntriesFromFileAsync(sessionFile));
     if (ownership.writable || ownership.state !== "moving" || ownership.moveId !== moveId)
         throw new MoveRefusal(RPC_ERROR_MOVE_NOT_RELEASED, "This session file is not sealed for this move. Release it with release_session reason move and this moveId first; that also hands back its queued input.");
 }
-function refuseOpenHere(port, sessionFile, detail) {
-    if (port.hostedPaths().some((path) => realSessionPath(path) === sessionFile))
+async function refuseOpenHere(port, sessionFile, detail) {
+    const hosted = await Promise.all(port.hostedPaths().map((path) => realSessionPath(path)));
+    if (hosted.includes(sessionFile))
         throw new MoveRefusal(RPC_ERROR_SESSION_OPEN_HERE, detail);
 }
 function answer(id, data) {

package/dist/modes/rpc/session-release.js

@@ -21,7 +21,7 @@
  * Also refused while clients are attached (`attached`, unless `force`) and for a session this host
  * cannot hand over (`release_unsupported`: a worker isolate owns the runtime, or there is no file).
  */
-import { rmSync } from "node:fs";
+import { rm } from "node:fs/promises";
 import { isMoveId, isPlainId, parseMoveId } from "../../core/session-move/bundle.js";
 import { prepareOutgoingState, STATE_ATTEMPT_FIELD } from "../../core/session-move/extension-state.js";
 import { SessionMovedAwayError } from "../../core/session-move/ownership.js";
@@ -79,7 +79,7 @@ export async function releaseSession(port, command) {
         // Each handler runs under the session_shutdown handler budget: a hung one fails the release instead of holding it.
         if (command.reason === "move") {
             const moveId = parseMoveId(command.moveId);
-            stagedState = prepareOutgoingState(first.sessionPath, moveId);
+            stagedState = await prepareOutgoingState(first.sessionPath, moveId);
             const [failed] = await first.session.extensionRunner.emitSessionMove({
                 type: "session_move_export",
                 moveId,
@@ -113,7 +113,7 @@ export async function releaseSession(port, command) {
             // A move refused before its seal is abandoned: what its export staged is never bundled, and a retry stages
             // afresh. Once the seal names this attempt, its folder is the move's state and stays for export.
             if (stagedState !== undefined && !sealed)
-                rmSync(stagedState.dir, { recursive: true, force: true });
+                await rm(stagedState.dir, { recursive: true, force: true });
         }
     }
 }

package/docs/release-guide.md

@@ -618,7 +618,7 @@ For the next release:
 
 1. Start from a clean, current `main`.
 2. Audit every commit since the latest tag.
-3. Update all affected package `[Unreleased]` sections.
+3. Record affected-package changelog entries in `changes/unreleased/<pr>.md`; the release cut compiles them before stamping.
 4. Duplicate user-facing AI, agent, and TUI changes into the coding-agent changelog.
 5. Query registry-verifiable plugin dependencies for newer exact versions.
 6. Preserve vendored snapshots when no authoritative upstream source is available.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@code-yeongyu/senpi",
-	"version": "2026.10.23-1",
+	"version": "2026.10.24-1",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -68,9 +68,9 @@
 	},
 	"dependencies": {
 		"@earendil-works/chord": "0.99.1",
-		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.23-1",
-		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.23-1",
-		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.23-1",
+		"@earendil-works/pi-agent-core": "npm:@code-yeongyu/senpi-agent-core@2026.10.24-1",
+		"@earendil-works/pi-ai": "npm:@code-yeongyu/senpi-ai@2026.10.24-1",
+		"@earendil-works/pi-tui": "npm:@code-yeongyu/senpi-tui@2026.10.24-1",
 		"@silvia-odwyer/photon-node": "0.3.4",
 		"chalk": "6.0.0",
 		"cross-spawn": "7.0.6",
@@ -89,8 +89,8 @@
 		"yaml": "2.9.1",
 		"@anthropic-ai/claude-agent-sdk": "0.3.306",
 		"@anthropic-ai/sdk": "0.127.0",
-		"@code-yeongyu/senpi-codemode": "2026.10.23-1",
-		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.23-1",
+		"@code-yeongyu/senpi-codemode": "2026.10.24-1",
+		"@earendil-works/pi-pty": "npm:@code-yeongyu/senpi-pty@2026.10.24-1",
 		"@modelcontextprotocol/sdk": "1.32.1",
 		"@mozilla/readability": "0.6.0",
 		"linkedom": "0.18.13",