@pi-harness/pi-harness 0.1.22 → 0.1.24

package/node_modules/@pi-harness/api-gateway/dist/index.js

@@ -1,28 +1,43 @@
 import { execFile } from "node:child_process";
-import { mkdir, mkdtemp, readFile, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { mkdir, mkdtemp, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { tmpdir } from "node:os";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
-import { MARKETPLACE_CAPABILITIES, MARKETPLACE_CATEGORIES, MARKETPLACE_PLUGINS, attachMarketplaceStatistics, createMarketplaceStatisticsLoader, paginateMarketplace, searchMarketplace, needsMarketplacePackageInstall, sortMarketplaceByRecommendation, } from "./marketplace.js";
+import { atomicWriteFile } from "@pi-harness/core";
+import { MARKETPLACE_CAPABILITIES, MARKETPLACE_CATEGORIES, MARKETPLACE_PLUGINS, attachMarketplaceStatistics, createMarketplaceStatisticsLoader, paginateMarketplace, searchMarketplace, needsMarketplacePackageInstall, marketplaceNpmPackageName, sortMarketplaceByRecommendation, } from "./marketplace.js";
 import { parseGitWorktrees } from "./workspaces.js";
 const loadMarketplaceStatistics = createMarketplaceStatisticsLoader();
+const DEFAULT_BODY_LIMIT_BYTES = 64 * 1024;
+const IMPORT_CONTENT_LIMIT_BYTES = 10 * 1024 * 1024;
+// The import body carries the JSONL content as a JSON string, so quotes and newlines are escaped; leave headroom above the content limit for that overhead.
+const IMPORT_BODY_LIMIT_BYTES = 16 * 1024 * 1024;
+// Retained trajectory events are replayed to every SSE client and returned by /api/session, so the array must stay bounded.
+const MAX_RETAINED_EVENTS = 2000;
+const GIT_TIMEOUT_MS = 15_000;
+class PayloadTooLargeError extends Error {
+    constructor() {
+        super("Request body is too large");
+        this.name = "PayloadTooLargeError";
+    }
+}
 function sendJson(response, status, payload) {
     const body = JSON.stringify(payload);
     response.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store", "content-length": Buffer.byteLength(body) });
     response.end(body);
 }
-async function bodyText(request) {
+// A multi-byte UTF-8 sequence can straddle a chunk boundary, so the raw bytes are collected and decoded once; decoding each chunk on its own would replace the split sequence with U+FFFD.
+async function bodyText(request, maxBytes = DEFAULT_BODY_LIMIT_BYTES) {
     const chunks = [];
     let length = 0;
     for await (const chunk of request) {
         const input = chunk;
-        const value = typeof input === "string" ? input : Buffer.from(input).toString("utf8");
-        length += Buffer.byteLength(value);
-        if (length > 64 * 1024)
-            throw new Error("Request body is too large");
-        chunks.push(value);
+        const buffer = typeof input === "string" ? Buffer.from(input, "utf8") : Buffer.isBuffer(input) ? input : Buffer.from(input);
+        length += buffer.length;
+        if (length > maxBytes)
+            throw new PayloadTooLargeError();
+        chunks.push(buffer);
     }
-    return chunks.join("");
+    return Buffer.concat(chunks).toString("utf8");
 }
 function errorText(error) {
     return error instanceof Error ? error.message : String(error);
@@ -42,10 +57,16 @@ function jsonSafe(value, seen = new WeakSet()) {
         return Object.prototype.toString.call(value);
     if (seen.has(value))
         return "[Circular]";
+    // Only the ancestors of the current node stay marked: a sibling that repeats the same object (Pi pushes one AgentMessage instance into both the message list and its events) is legitimate data, not a cycle.
     seen.add(value);
-    if (Array.isArray(value))
-        return value.map((item) => jsonSafe(item, seen));
-    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonSafe(item, seen)]));
+    try {
+        if (Array.isArray(value))
+            return value.map((item) => jsonSafe(item, seen));
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, jsonSafe(item, seen)]));
+    }
+    finally {
+        seen.delete(value);
+    }
 }
 function createStatus(services, events) {
     const activeModel = services.runtime.session.model ?? services.models.model;
@@ -106,26 +127,63 @@ function piConfig(services) {
 function sessionMetadataFile(manager) {
     return resolve(manager.getSessionDir(), ".pi-harness-session-meta.json");
 }
-async function readSessionMetadata(manager) {
+// A missing file is the normal first-run state. Any other read or parse failure means the file exists but is unusable; it is renamed aside so the wreckage survives for recovery and the next write cannot silently replace the only copy.
+async function readSessionMetadata(manager, logger) {
+    const file = sessionMetadataFile(manager);
+    let raw;
     try {
-        const parsed = JSON.parse(await readFile(sessionMetadataFile(manager), "utf8"));
-        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        raw = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
             return {};
+        await quarantineSessionMetadata(file, logger, error);
+        return {};
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("session metadata must be a JSON object");
         return parsed;
     }
-    catch {
+    catch (error) {
+        await quarantineSessionMetadata(file, logger, error);
         return {};
     }
 }
+async function quarantineSessionMetadata(file, logger, error) {
+    const quarantined = `${file}.corrupt-${Date.now()}`;
+    try {
+        await rename(file, quarantined);
+        logger.warn(`Session metadata at ${file} is unreadable (${errorText(error)}); moved it to ${quarantined} and starting from an empty map`);
+    }
+    catch (renameError) {
+        logger.warn(`Session metadata at ${file} is unreadable (${errorText(error)}) and could not be quarantined: ${errorText(renameError)}`);
+    }
+}
 async function writeSessionMetadata(manager, metadata) {
     await mkdir(manager.getSessionDir(), { recursive: true });
-    await writeFile(sessionMetadataFile(manager), JSON.stringify(metadata, null, 2) + "\n", "utf8");
+    await atomicWriteFile(sessionMetadataFile(manager), JSON.stringify(metadata, null, 2) + "\n", { encoding: "utf8" });
+}
+// Every read-modify-write of the metadata file runs through this chain so concurrent requests cannot interleave and drop each other's updates.
+let sessionMetadataQueue = Promise.resolve();
+function mutateSessionMetadata(manager, logger, mutate) {
+    const operation = sessionMetadataQueue
+        .catch(() => undefined)
+        .then(async () => {
+        const metadata = await readSessionMetadata(manager, logger);
+        const result = await mutate(metadata);
+        await writeSessionMetadata(manager, metadata);
+        return result;
+    });
+    sessionMetadataQueue = operation;
+    return operation;
 }
 function sessionPathInDirectory(path, manager) {
     const root = resolve(manager.getSessionDir());
     const target = resolve(path);
     const relativePath = relative(root, target);
-    return relativePath !== "" && !isAbsolute(relativePath) && relativePath !== ".." && !relativePath.startsWith(".." + "/") && target.endsWith(".jsonl");
+    return relativePath !== "" && !isAbsolute(relativePath) && relativePath !== ".." && !relativePath.startsWith(".." + sep) && target.endsWith(".jsonl");
 }
 const webSessionUi = {
     select: (_title, options) => Promise.resolve(options[0]),
@@ -255,6 +313,7 @@ function sanitizeLogValue(value, state, depth = 0) {
         return "[Max Depth]";
     if (state.seen.has(value))
         return "[Circular]";
+    // Unmarked once its subtree is done, so an object logged twice as a sibling is rendered twice instead of being mistaken for a cycle.
     state.seen.add(value);
     try {
         if (value instanceof Date)
@@ -288,6 +347,9 @@ function sanitizeLogValue(value, state, depth = 0) {
     catch {
         return "[Unavailable]";
     }
+    finally {
+        state.seen.delete(value);
+    }
 }
 function sanitizeLogArguments(args) {
     const sanitized = sanitizeLogValue(args, { remaining: loggerPanelNodeLimit, seen: new WeakSet() });
@@ -412,21 +474,53 @@ async function updateMarketplaceProfile(configPath, entryId, update) {
 function writeSse(response, payload) {
     response.write(`data: ${JSON.stringify(jsonSafe(payload))}\n\n`);
 }
+// Node reports a maxBuffer overflow through a string error code and a timeout through `killed`; neither is a git exit status, so they must not be folded into an ordinary non-zero exit.
+function gitTermination(error) {
+    if (error === null)
+        return undefined;
+    if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER")
+        return "output-limit";
+    if (error.killed === true)
+        return "timeout";
+    return undefined;
+}
+function gitTerminationMessage(command, termination) {
+    return termination === "timeout"
+        ? `git ${command} timed out after ${GIT_TIMEOUT_MS / 1000} seconds`
+        : `git ${command} produced more output than the buffer limit allows`;
+}
+// `-z` is what makes the paths usable: without it git wraps any path holding a space, a quote or a non-ASCII byte in C-style quoting, and the quoted form is not a pathspec git will accept back on diff, add or ls-files.
 function gitStatus(cwd) {
-    return new Promise((resolve) => {
-        execFile("git", ["status", "--short", "--untracked-files=all"], { cwd, maxBuffer: 512 * 1024 }, (error, stdout) => resolve(error ? "" : stdout));
+    return new Promise((resolveStatus, rejectStatus) => {
+        execFile("git", ["status", "--short", "-z", "--untracked-files=all"], { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: 512 * 1024 }, (error, stdout, stderr) => {
+            if (error === null) {
+                resolveStatus({ output: stdout, truncated: false });
+                return;
+            }
+            const termination = gitTermination(error);
+            if (termination === "output-limit") {
+                // Keep the complete records that arrived before the kill; the final one may have been cut mid-path.
+                resolveStatus({ output: stdout.slice(0, stdout.lastIndexOf("\0") + 1), truncated: true });
+                return;
+            }
+            if (termination === undefined && error.code === 128 && /not a git repository/i.test(stderr)) {
+                resolveStatus({ output: "", truncated: false });
+                return;
+            }
+            rejectStatus(new Error(termination ? gitTerminationMessage("status", termination) : stderr.trim() || error.message, { cause: error }));
+        });
     });
 }
 function gitDiff(cwd, path) {
     return new Promise((resolveOutput) => {
-        execFile("git", ["diff", "--no-ext-diff", "--", path], { cwd, maxBuffer: 1024 * 1024 }, (error, stdout) => resolveOutput(error && stdout.length === 0 ? "" : stdout));
+        execFile("git", ["diff", "--no-ext-diff", "--", path], { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: 1024 * 1024 }, (error, stdout) => resolveOutput(error && stdout.length === 0 ? "" : stdout));
     });
 }
 function gitCommand(cwd, args) {
     return new Promise((resolveResult) => {
-        execFile("git", [...args], { cwd, maxBuffer: 2 * 1024 * 1024 }, (error, stdout, stderr) => {
+        execFile("git", [...args], { cwd, timeout: GIT_TIMEOUT_MS, maxBuffer: 2 * 1024 * 1024 }, (error, stdout, stderr) => {
             const code = error && typeof error.code === "number" ? error.code : error ? 1 : 0;
-            resolveResult({ stdout, stderr, code });
+            resolveResult({ stdout, stderr, code, terminated: gitTermination(error) });
         });
     });
 }
@@ -457,6 +551,26 @@ async function isDirectory(path) {
         return false;
     }
 }
+async function isFile(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+// The loader resolves a bare plugin specifier from the profile file upwards (`createRequire(profilePath).resolve(name)`), never from the shell the harness was started in, so a marketplace package has to land in the package that owns the profile or it installs successfully and then fails to load.
+async function marketplaceInstallDirectory(configPath, fallback) {
+    let directory = dirname(resolve(configPath));
+    let parent = dirname(directory);
+    while (parent !== directory) {
+        if (await isFile(join(directory, "package.json")))
+            return directory;
+        directory = parent;
+        parent = dirname(directory);
+    }
+    return fallback;
+}
 function pickDirectory() {
     return new Promise((resolvePath, reject) => {
         execFile("osascript", ["-e", 'POSIX path of (choose folder with prompt "选择 Pi 工作区")'], { timeout: 120_000, maxBuffer: 64 * 1024 }, (error, stdout, stderr) => {
@@ -503,7 +617,12 @@ export default {
         const events = [];
         const eventClients = new Set();
         const handleEvent = (event) => {
-            events.push(event);
+            // Streaming deltas reach clients live over SSE and each one carries the whole partial message, so only durable events are retained for snapshots.
+            if (event.type !== "message_update") {
+                events.push(event);
+                if (events.length > MAX_RETAINED_EVENTS)
+                    events.splice(0, events.length - MAX_RETAINED_EVENTS);
+            }
             for (const response of eventClients) {
                 if (response.writableEnded || response.destroyed) {
                     eventClients.delete(response);
@@ -639,7 +758,9 @@ export default {
                         return;
                     }
                     const path = join(services.launch.agentDir, "settings.json");
-                    await writeFile(path, JSON.stringify(parsed, null, 2) + "\n", "utf8");
+                    // Replace the file atomically so an interrupted write never leaves a truncated settings.json behind; keep the existing permission bits.
+                    const mode = await stat(path).then((info) => info.mode & 0o777, () => 0o644);
+                    await atomicWriteFile(path, JSON.stringify(parsed, null, 2) + "\n", { encoding: "utf8", mode });
                     await services.runtime.session.settingsManager.reload();
                     sendJson(response, 200, piConfig(services));
                 }
@@ -900,15 +1021,17 @@ export default {
                         sendJson(response, 409, { error: "Plugin is already installed", plugin });
                         return;
                     }
-                    const packageJsonPath = join(services.launch.cwd, "package.json");
-                    const packageLockPath = join(services.launch.cwd, "package-lock.json");
+                    const installDirectory = await marketplaceInstallDirectory(configPath, services.launch.cwd);
+                    const packageJsonPath = join(installDirectory, "package.json");
+                    const packageLockPath = join(installDirectory, "package-lock.json");
                     const packageJsonBefore = await readFile(packageJsonPath, "utf8").catch(() => undefined);
                     const packageLockBefore = await readFile(packageLockPath, "utf8").catch(() => undefined);
                     let profileBefore;
                     let entryId;
                     try {
                         if (needsMarketplacePackageInstall(plugin)) {
-                            await runProcess("npm", ["install", "--save-exact", "--package-lock=false", `${plugin.packageName}@${plugin.version}`], services.launch.cwd);
+                            const specifier = `${marketplaceNpmPackageName(plugin.packageName)}@${plugin.version}`;
+                            await runProcess("npm", ["install", "--save-exact", "--package-lock=false", specifier], installDirectory);
                         }
                         profileBefore = await appendMarketplaceProfile(configPath, plugin);
                         if (!needsMarketplacePackageInstall(plugin)) {
@@ -932,9 +1055,14 @@ export default {
                             await loader.remove(entryId).catch(() => { });
                         if (profileBefore !== undefined)
                             await writeFile(configPath, profileBefore, "utf8").catch(() => { });
-                        if (packageJsonBefore !== undefined)
+                        // A manifest npm created for this install is removed rather than left behind; restoring is only possible when one existed before.
+                        if (packageJsonBefore === undefined)
+                            await unlink(packageJsonPath).catch(() => { });
+                        else
                             await writeFile(packageJsonPath, packageJsonBefore, "utf8").catch(() => { });
-                        if (packageLockBefore !== undefined)
+                        if (packageLockBefore === undefined)
+                            await unlink(packageLockPath).catch(() => { });
+                        else
                             await writeFile(packageLockPath, packageLockBefore, "utf8").catch(() => { });
                         sendJson(response, 502, { error: errorText(error) });
                     }
@@ -1036,8 +1164,9 @@ export default {
                     }
                     const profileEntryId = entry.options.id;
                     const profileBefore = await readFile(configPath, "utf8");
-                    const packageJsonPath = join(services.launch.cwd, "package.json");
-                    const packageLockPath = join(services.launch.cwd, "package-lock.json");
+                    const installDirectory = await marketplaceInstallDirectory(configPath, services.launch.cwd);
+                    const packageJsonPath = join(installDirectory, "package.json");
+                    const packageLockPath = join(installDirectory, "package-lock.json");
                     const packageJsonBefore = await readFile(packageJsonPath, "utf8").catch(() => undefined);
                     const packageLockBefore = await readFile(packageLockPath, "utf8").catch(() => undefined);
                     await entry.parent.remove(entry.options.id);
@@ -1045,7 +1174,7 @@ export default {
                     try {
                         await updateMarketplaceProfile(configPath, profileEntryId, { remove: true });
                         if (needsMarketplacePackageInstall(plugin))
-                            await runProcess("npm", ["uninstall", "--package-lock=false", plugin.packageName], services.launch.cwd);
+                            await runProcess("npm", ["uninstall", "--package-lock=false", marketplaceNpmPackageName(plugin.packageName)], installDirectory);
                         sendJson(response, 200, { uninstalled: true, id: payload.id });
                     }
                     catch (error) {
@@ -1149,20 +1278,31 @@ export default {
         const disposeFiles = services.webServer.register({
             path: "/api/files",
             async handler(_request, response) {
-                const output = await gitStatus(activeCwd(services));
-                const items = output
-                    .split("\n")
-                    .map((line) => line.trimEnd())
-                    .filter((line) => line.length > 0)
-                    .map((line) => {
-                    const status = line.slice(0, 2).trim() || "??";
-                    return {
-                        path: line.slice(3),
-                        status,
-                        label: status === "??" ? "untracked" : status.includes("D") ? "deleted" : status.includes("A") ? "added" : "modified",
-                    };
-                });
-                sendJson(response, 200, { items });
+                let status;
+                try {
+                    status = await gitStatus(activeCwd(services));
+                }
+                catch (error) {
+                    sendJson(response, 500, { error: errorText(error) });
+                    return;
+                }
+                const records = status.output.split("\0");
+                const items = [];
+                for (let index = 0; index < records.length; index += 1) {
+                    const record = records[index] ?? "";
+                    if (record.length < 4)
+                        continue;
+                    const code = record.slice(0, 2).trim() || "??";
+                    // Rename and copy records carry the original path in a second NUL-terminated field, which is not a workspace change of its own.
+                    if (code.startsWith("R") || code.startsWith("C"))
+                        index += 1;
+                    items.push({
+                        path: record.slice(3),
+                        status: code,
+                        label: code === "??" ? "untracked" : code.includes("D") ? "deleted" : code.includes("A") ? "added" : "modified",
+                    });
+                }
+                sendJson(response, 200, { items, ...(status.truncated ? { truncated: true } : {}) });
             },
         });
         const disposeFileDiff = services.webServer.register({
@@ -1181,7 +1321,7 @@ export default {
                 const root = resolve(activeCwd(services));
                 const absolute = resolve(root, requested);
                 const relativePath = relative(root, absolute);
-                if (isAbsolute(relativePath) || relativePath === ".." || relativePath.startsWith(".." + "/")) {
+                if (isAbsolute(relativePath) || relativePath === ".." || relativePath.startsWith(".." + sep)) {
                     sendJson(response, 400, { error: "path must stay inside the workspace" });
                     return;
                 }
@@ -1208,11 +1348,19 @@ export default {
                     }
                     const root = resolve(activeCwd(services));
                     const add = await gitCommand(root, ["add", "-A", "--", ...paths]);
+                    if (add.terminated) {
+                        sendJson(response, 500, { error: gitTerminationMessage("add", add.terminated) });
+                        return;
+                    }
                     if (add.code !== 0) {
                         sendJson(response, 409, { error: add.stderr.trim() || "Unable to stage workspace files" });
                         return;
                     }
                     const commit = await gitCommand(root, ["commit", "-m", payload.message.trim(), "--", ...paths]);
+                    if (commit.terminated) {
+                        sendJson(response, 500, { error: gitTerminationMessage("commit", commit.terminated) });
+                        return;
+                    }
                     if (commit.code !== 0) {
                         sendJson(response, 409, { error: commit.stdout.trim() || commit.stderr.trim() || "Nothing to commit" });
                         return;
@@ -1244,16 +1392,39 @@ export default {
                         sendJson(response, 400, { error: paths.message });
                         return;
                     }
-                    const untracked = await gitCommand(root, ["ls-files", "--others", "--exclude-standard", "--", ...paths]);
-                    const restore = await gitCommand(root, ["restore", "--worktree", "--staged", "--", ...paths]);
-                    if (restore.code !== 0 && !restore.stderr.includes("pathspec")) {
-                        sendJson(response, 409, { error: restore.stderr.trim() || "Unable to restore workspace files" });
+                    const untracked = await gitCommand(root, ["ls-files", "-z", "--others", "--exclude-standard", "--", ...paths]);
+                    // `git restore` refuses the whole request when any pathspec is unknown to it, so restore only the paths git tracks. `--with-tree=HEAD` keeps staged deletions in the list; it fails on an unborn HEAD, where the plain index listing is all there is.
+                    let tracked = await gitCommand(root, ["ls-files", "-z", "--with-tree=HEAD", "--", ...paths]);
+                    if (tracked.code !== 0 && tracked.terminated === undefined)
+                        tracked = await gitCommand(root, ["ls-files", "-z", "--", ...paths]);
+                    const listing = [untracked, tracked].find((result) => result.terminated !== undefined || result.code !== 0);
+                    if (listing) {
+                        if (listing.terminated)
+                            sendJson(response, 500, { error: gitTerminationMessage("ls-files", listing.terminated) });
+                        else
+                            sendJson(response, 409, { error: listing.stderr.trim() || "Unable to inspect workspace files" });
+                        return;
+                    }
+                    const untrackedPaths = untracked.stdout.split("\0").filter(Boolean);
+                    const trackedPaths = tracked.stdout.split("\0").filter(Boolean);
+                    const known = [...untrackedPaths, ...trackedPaths];
+                    const unknown = paths.filter((path) => !known.some((candidate) => candidate === path || candidate.startsWith(path + "/")));
+                    if (unknown.length > 0) {
+                        sendJson(response, 409, { error: `Paths did not match any file known to git: ${unknown.join(", ")}` });
                         return;
                     }
-                    for (const path of untracked.stdout
-                        .split("\n")
-                        .map((item) => item.trim())
-                        .filter(Boolean)) {
+                    if (trackedPaths.length > 0) {
+                        const restore = await gitCommand(root, ["restore", "--worktree", "--staged", "--", ...trackedPaths]);
+                        if (restore.terminated) {
+                            sendJson(response, 500, { error: gitTerminationMessage("restore", restore.terminated) });
+                            return;
+                        }
+                        if (restore.code !== 0) {
+                            sendJson(response, 409, { error: restore.stderr.trim() || "Unable to restore workspace files" });
+                            return;
+                        }
+                    }
+                    for (const path of untrackedPaths) {
                         await rm(resolve(root, path), { recursive: true, force: true });
                     }
                     sendJson(response, 200, { reverted: true, paths });
@@ -1291,6 +1462,10 @@ export default {
         const disposePrompt = services.webServer.register({
             path: "/api/prompt",
             async handler(request, response) {
+                if (request.method !== "POST") {
+                    sendJson(response, 405, { error: "Method not allowed" });
+                    return;
+                }
                 if (busy) {
                     sendJson(response, 409, { error: "Another prompt is already running" });
                     return;
@@ -1541,9 +1716,9 @@ export default {
                         events.length = 0;
                     }
                     await unlink(path);
-                    const metadata = await readSessionMetadata(manager);
-                    delete metadata[path];
-                    await writeSessionMetadata(manager, metadata);
+                    await mutateSessionMetadata(manager, context.logger, (metadata) => {
+                        delete metadata[path];
+                    });
                     sendJson(response, 200, { deleted: true, path, sessionFile: services.runtime.session.sessionFile });
                 }
                 catch (error) {
@@ -1566,16 +1741,17 @@ export default {
                         sendJson(response, 400, { error: "Invalid session path" });
                         return;
                     }
-                    const metadata = await readSessionMetadata(manager);
-                    const currentMetadata = metadata[path] ?? {};
-                    const nextMetadata = {
-                        ...currentMetadata,
-                        ...(payload.archived === undefined ? {} : { archived: payload.archived === true }),
-                        ...(payload.pinned === undefined ? {} : { pinned: payload.pinned === true }),
-                    };
-                    metadata[path] = nextMetadata;
-                    await writeSessionMetadata(manager, metadata);
-                    sendJson(response, 200, { path, metadata: metadata[path] });
+                    const nextMetadata = await mutateSessionMetadata(manager, context.logger, (metadata) => {
+                        const currentMetadata = metadata[path] ?? {};
+                        const updated = {
+                            ...currentMetadata,
+                            ...(payload.archived === undefined ? {} : { archived: payload.archived === true }),
+                            ...(payload.pinned === undefined ? {} : { pinned: payload.pinned === true }),
+                        };
+                        metadata[path] = updated;
+                        return updated;
+                    });
+                    sendJson(response, 200, { path, metadata: nextMetadata });
                 }
                 catch (error) {
                     sendJson(response, 400, { error: errorText(error) });
@@ -1612,13 +1788,41 @@ export default {
                         sendJson(response, 409, { error: "Cannot batch-delete the active session" });
                         return;
                     }
-                    const metadata = await readSessionMetadata(manager);
-                    for (const path of paths) {
-                        if (action === "delete") {
-                            await unlink(path);
-                            delete metadata[path];
+                    if (action === "delete") {
+                        // The unlinks run outside the metadata mutation: a failure halfway through must not discard the key removals for the files that are already gone from disk.
+                        const removed = [];
+                        const failed = [];
+                        for (const path of paths) {
+                            try {
+                                await unlink(path);
+                                removed.push(path);
+                            }
+                            catch (error) {
+                                // A session another tab already deleted leaves nothing to unlink, but its metadata entry still has to go.
+                                if (error.code === "ENOENT")
+                                    removed.push(path);
+                                else
+                                    failed.push({ path, error: errorText(error) });
+                            }
                         }
-                        else {
+                        await mutateSessionMetadata(manager, context.logger, (metadata) => {
+                            for (const path of removed)
+                                delete metadata[path];
+                        });
+                        if (failed.length > 0) {
+                            sendJson(response, 409, {
+                                error: `Some sessions could not be deleted: ${failed.map((item) => item.path).join(", ")}`,
+                                action,
+                                count: removed.length,
+                                failed,
+                            });
+                            return;
+                        }
+                        sendJson(response, 200, { action, count: removed.length });
+                        return;
+                    }
+                    await mutateSessionMetadata(manager, context.logger, (metadata) => {
+                        for (const path of paths) {
                             const current = metadata[path] ?? {};
                             metadata[path] = {
                                 ...current,
@@ -1626,8 +1830,7 @@ export default {
                                 ...(action === "pin" || action === "unpin" ? { pinned: action === "pin" } : {}),
                             };
                         }
-                    }
-                    await writeSessionMetadata(manager, metadata);
+                    });
                     sendJson(response, 200, { action, count: paths.length });
                 }
                 catch (error) {
@@ -1677,11 +1880,16 @@ export default {
                     return;
                 }
                 try {
-                    const payload = JSON.parse(await bodyText(request));
+                    const payload = JSON.parse(await bodyText(request, IMPORT_BODY_LIMIT_BYTES));
                     const suppliedPath = typeof payload.path === "string" ? payload.path : "";
                     const content = typeof payload.content === "string" ? payload.content : undefined;
-                    if ((!suppliedPath || !isAbsolute(suppliedPath)) && content === undefined) {
-                        sendJson(response, 400, { error: "A JSONL file path or file content is required" });
+                    // `path` reads an existing file and `content` is written to a private temporary file; accepting both would let the request choose where the content lands.
+                    if (suppliedPath && content !== undefined) {
+                        sendJson(response, 400, { error: "Provide either a JSONL file path or file content, not both" });
+                        return;
+                    }
+                    if (content === undefined && (!suppliedPath || !isAbsolute(suppliedPath) || !suppliedPath.endsWith(".jsonl"))) {
+                        sendJson(response, 400, { error: "An absolute .jsonl file path or file content is required" });
                         return;
                     }
                     const manager = services.runtime.session.sessionManager;
@@ -1691,11 +1899,12 @@ export default {
                     }
                     const targetCwd = typeof payload.cwd === "string" && payload.cwd.trim() ? resolve(payload.cwd) : activeCwd(services);
                     const temporaryDirectory = content === undefined ? undefined : await mkdtemp(join(tmpdir(), "pi-harness-import-"));
-                    const importPath = suppliedPath ||
-                        join(temporaryDirectory, basename(typeof payload.filename === "string" && payload.filename.trim() ? payload.filename : "import.jsonl"));
+                    const requestedName = basename(typeof payload.filename === "string" && payload.filename.trim() ? payload.filename : "import.jsonl");
+                    const importName = requestedName === "" || requestedName === "." || requestedName === ".." ? "import.jsonl" : requestedName;
+                    const importPath = temporaryDirectory === undefined ? suppliedPath : join(temporaryDirectory, importName);
                     try {
                         if (content !== undefined) {
-                            if (Buffer.byteLength(content, "utf8") > 10 * 1024 * 1024) {
+                            if (Buffer.byteLength(content, "utf8") > IMPORT_CONTENT_LIMIT_BYTES) {
                                 sendJson(response, 413, { error: "Imported session must be at most 10 MiB" });
                                 return;
                             }
@@ -1723,7 +1932,7 @@ export default {
                     }
                 }
                 catch (error) {
-                    sendJson(response, 400, { error: errorText(error) });
+                    sendJson(response, error instanceof PayloadTooLargeError ? 413 : 400, { error: errorText(error) });
                 }
             },
         });
@@ -1761,7 +1970,7 @@ export default {
                     const page = Math.max(0, Number.parseInt(url.searchParams.get("page") ?? "0", 10) || 0);
                     const pageSize = Math.min(100, Math.max(1, Number.parseInt(url.searchParams.get("pageSize") ?? "50", 10) || 50));
                     const includeArchived = url.searchParams.get("includeArchived") === "true";
-                    const metadata = await readSessionMetadata(manager);
+                    const metadata = await readSessionMetadata(manager, context.logger);
                     const items = typeof manager.isPersisted === "function" && manager.isPersisted() ? await SessionManager.list(services.launch.cwd, manager.getSessionDir()) : [];
                     const filtered = items.filter((item) => includeArchived || metadata[item.path]?.archived !== true);
                     const sorted = filtered.sort((a, b) => Number(metadata[b.path]?.pinned === true) - Number(metadata[a.path]?.pinned === true) || b.modified.getTime() - a.modified.getTime());