@hachej/boring-agent 0.1.94 → 0.1.96

package/dist/{chunk-2TMS2RU2.js → chunk-WC5KBGP2.js}

@@ -1,22 +1,20 @@
 import {
+  SAFE_NATIVE_SESSION_ID,
   noopTelemetry,
   safeCapture
-} from "./chunk-AQBXNPMD.js";
+} from "./chunk-4IQ4HHBG.js";
 import {
   ErrorCode
-} from "./chunk-2GBHYJVC.js";
+} from "./chunk-VXF5DWS6.js";
 
 // src/server/harness/pi-coding-agent/createHarness.ts
-import { AsyncLocalStorage } from "async_hooks";
-import { existsSync, readFileSync as readFileSync2 } from "fs";
-import { extname, join as join2 } from "path";
+import { AsyncLocalStorage } from "node:async_hooks";
 import {
   createAgentSession,
-  SessionManager,
+  SessionManager as SessionManager2,
   AuthStorage,
   ModelRegistry,
   DefaultResourceLoader,
-  SettingsManager as SettingsManager2,
   getAgentDir as getAgentDir2,
   loadSkills
 } from "@mariozechner/pi-coding-agent";
@@ -298,21 +296,21 @@ function createPiAgentSessionAdapter(session, options = {}) {
 }
 
 // src/server/harness/pi-coding-agent/sessions.ts
-import { randomUUID } from "crypto";
+import { randomUUID } from "node:crypto";
 import {
   readdir,
   readFile,
-  stat as fsStat,
+  stat as fsStat2,
   rm,
   mkdir,
   writeFile,
   appendFile,
   rename,
-  open
-} from "fs/promises";
-import { closeSync, openSync, readFileSync, readSync, readdirSync, writeFileSync } from "fs";
-import { join, basename, resolve } from "path";
-import { homedir } from "os";
+  open as open4
+} from "node:fs/promises";
+import { closeSync, openSync, readFileSync, readSync, readdirSync, writeFileSync } from "node:fs";
+import { join, basename, resolve } from "node:path";
+import { homedir } from "node:os";
 
 // src/server/config/env.ts
 function getEnv(name) {
@@ -322,8 +320,253 @@ function getEnv(name) {
 // src/server/harness/pi-coding-agent/sessions.ts
 import {
   parseSessionEntries,
-  CURRENT_SESSION_VERSION
+  CURRENT_SESSION_VERSION as CURRENT_SESSION_VERSION2
 } from "@mariozechner/pi-coding-agent";
+
+// src/server/harness/pi-coding-agent/nativeSessionRename.ts
+import { open as open2, stat as fsStat, utimes } from "node:fs/promises";
+import {
+  CURRENT_SESSION_VERSION,
+  SessionManager
+} from "@mariozechner/pi-coding-agent";
+
+// src/server/harness/pi-coding-agent/sessionJsonlPrefix.ts
+import { open } from "node:fs/promises";
+var SUMMARY_PREFIX_BYTES = 64 * 1024;
+async function readJsonlPrefix(filepath, maxBytes = SUMMARY_PREFIX_BYTES) {
+  const handle = await open(filepath, "r");
+  try {
+    const buffer = Buffer.alloc(maxBytes);
+    const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
+    return completeJsonlPrefix(buffer.subarray(0, bytesRead).toString("utf-8"), bytesRead === maxBytes);
+  } finally {
+    await handle.close();
+  }
+}
+function parseJsonlPrefixEntries(content) {
+  const entries = [];
+  for (const line of content.split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return entries;
+}
+function completeJsonlPrefix(content, reachedLimit) {
+  if (!reachedLimit) return content;
+  const lastNewline = content.lastIndexOf("\n");
+  return lastNewline >= 0 ? content.slice(0, lastNewline + 1) : content;
+}
+
+// src/server/harness/pi-coding-agent/nativeSessionRename.ts
+var NATIVE_RENAME_MAX_APPEND_BYTES = 64 * 1024;
+var NATIVE_RENAME_MAX_ATTEMPTS = 3;
+async function restoreVerifiedNativeRenameMtime(filepath, before, verifiedSize) {
+  try {
+    const current = await fsStat(filepath);
+    if (current.dev !== before.dev || current.ino !== before.ino || current.size !== verifiedSize) return;
+    const atimeSeconds = fileTimeSeconds(before.atimeMs);
+    const mtimeSeconds = fileTimeSeconds(before.mtimeMs);
+    if (atimeSeconds === void 0 || mtimeSeconds === void 0) return;
+    await utimes(filepath, atimeSeconds, mtimeSeconds);
+    const restored = await fsStat(filepath);
+    if (restored.size !== verifiedSize) {
+      const restoredAtimeSeconds = fileTimeSeconds(restored.atimeMs);
+      if (restoredAtimeSeconds !== void 0) await utimes(filepath, restoredAtimeSeconds, Date.now() / 1e3);
+    }
+  } catch {
+  }
+}
+async function verifiedNativeRenameAppend(filepath, before, append, title) {
+  const after = await fsStat(filepath);
+  if (after.dev !== before.dev || after.ino !== before.ino) return null;
+  const appendedBytes = after.size - before.size;
+  if (!Number.isSafeInteger(before.size) || !Number.isSafeInteger(after.size) || appendedBytes <= 0 || appendedBytes > NATIVE_RENAME_MAX_APPEND_BYTES) return null;
+  const handle = await open2(filepath, "r");
+  try {
+    const record = Buffer.allocUnsafe(appendedBytes);
+    const { bytesRead } = await handle.read(record, 0, record.length, before.size);
+    if (bytesRead !== record.length || record.at(-1) !== 10 || record.indexOf(10) !== record.length - 1) return null;
+    const parsed = JSON.parse(record.toString("utf-8"));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    const entry = parsed;
+    return entry.type === "session_info" && entry.id === append.id && entry.parentId === append.parentId && entry.name === title ? after.size : null;
+  } catch {
+    return null;
+  } finally {
+    await handle.close();
+  }
+}
+function latestConcurrentEntryId(manager, staleRenameIds) {
+  for (const entry of manager.getEntries().reverse()) {
+    if (!staleRenameIds.has(entry.id)) return entry.id;
+  }
+  return null;
+}
+function nativeRenameLockedError(message = "native session changed while renaming; retry") {
+  return Object.assign(new Error(message), {
+    code: ErrorCode.enum.SESSION_LOCKED,
+    statusCode: 409,
+    retryable: true
+  });
+}
+async function appendVerifiedNativeRename(filepath, sessionDir, cwd, title) {
+  const staleRenameIds = /* @__PURE__ */ new Set();
+  for (let attempt = 0; attempt < NATIVE_RENAME_MAX_ATTEMPTS; attempt += 1) {
+    try {
+      const before = await fsStat(filepath);
+      const header = parseJsonlPrefixEntries(await readJsonlPrefix(filepath)).find(
+        (entry) => entry.type === "session"
+      );
+      if (header?.version !== CURRENT_SESSION_VERSION) {
+        throw nativeRenameLockedError("This native session was created by an unsupported Pi version and cannot be renamed.");
+      }
+      const manager = SessionManager.open(filepath, sessionDir, cwd);
+      if (staleRenameIds.size > 0) {
+        const concurrentLeaf = latestConcurrentEntryId(manager, staleRenameIds);
+        if (!concurrentLeaf) break;
+        manager.branch(concurrentLeaf);
+      }
+      const append = {
+        parentId: manager.getLeafId(),
+        id: manager.appendSessionInfo(title)
+      };
+      staleRenameIds.add(append.id);
+      const verifiedSize = await verifiedNativeRenameAppend(filepath, before, append, title);
+      if (verifiedSize !== null) {
+        await restoreVerifiedNativeRenameMtime(filepath, before, verifiedSize);
+        return;
+      }
+    } catch (error) {
+      if (error.code === ErrorCode.enum.SESSION_LOCKED) throw error;
+    }
+  }
+  throw nativeRenameLockedError();
+}
+function fileTimeSeconds(milliseconds) {
+  const seconds = milliseconds / 1e3;
+  return Number.isFinite(seconds) ? seconds : void 0;
+}
+
+// src/server/harness/pi-coding-agent/nativeSessionTranscript.ts
+import { createReadStream } from "node:fs";
+import { open as open3 } from "node:fs/promises";
+import { createInterface } from "node:readline";
+
+// src/server/harness/pi-coding-agent/piSessionMessages.ts
+function textFromPiContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => {
+    const item = part;
+    return item?.type === "text" && typeof item.text === "string" ? item.text : "";
+  }).join("");
+}
+
+// src/server/harness/pi-coding-agent/nativeSessionTranscript.ts
+var NATIVE_TAIL_CHUNK_BYTES = 64 * 1024;
+var NATIVE_TAIL_MAX_RECORD_BYTES = 256 * 1024;
+var NATIVE_TAIL_MAX_RECORD_FRAGMENTS = 4;
+async function latestNativeMessageTimestamp(filepath, size) {
+  const handle = await open3(filepath, "r");
+  let end = size;
+  let lineFragments = [];
+  try {
+    while (end > 0) {
+      const start = Math.max(0, end - NATIVE_TAIL_CHUNK_BYTES);
+      const chunk = Buffer.alloc(end - start);
+      const { bytesRead } = await handle.read(chunk, 0, chunk.length, start);
+      let lineEnd = bytesRead;
+      while (lineEnd > 0) {
+        const newline = chunk.lastIndexOf(10, lineEnd - 1);
+        if (newline < 0) break;
+        const timestamp = nativeMessageTimestampFromBoundedPrefix(
+          nativeTailRecordPrefix(chunk.subarray(newline + 1, lineEnd), lineFragments)
+        );
+        lineFragments = [];
+        if (timestamp !== void 0) return timestamp;
+        lineEnd = newline;
+      }
+      if (lineEnd > 0) {
+        lineFragments = retainNativeTailFragment(chunk.subarray(0, lineEnd), lineFragments);
+      }
+      end = start;
+    }
+    return nativeMessageTimestampFromBoundedPrefix(
+      nativeTailRecordPrefix(lineFragments.at(-1) ?? Buffer.alloc(0), lineFragments.slice(0, -1))
+    );
+  } finally {
+    await handle.close();
+  }
+}
+function retainNativeTailFragment(fragment, fragments) {
+  const next = [...fragments, fragment.subarray(0, NATIVE_TAIL_MAX_RECORD_BYTES)];
+  while (next.length > NATIVE_TAIL_MAX_RECORD_FRAGMENTS || nativeTailFragmentBytes(next) > NATIVE_TAIL_MAX_RECORD_BYTES) {
+    next.shift();
+  }
+  return next;
+}
+function nativeTailFragmentBytes(fragments) {
+  return fragments.reduce((total, fragment) => total + fragment.length, 0);
+}
+function nativeTailRecordPrefix(recordStart, followingFragments) {
+  const total = Math.min(
+    NATIVE_TAIL_MAX_RECORD_BYTES,
+    recordStart.length + nativeTailFragmentBytes(followingFragments)
+  );
+  const prefix = Buffer.allocUnsafe(total);
+  let offset = 0;
+  for (const fragment of [recordStart, ...followingFragments.slice().reverse()]) {
+    const length = Math.min(fragment.length, total - offset);
+    if (length <= 0) break;
+    fragment.copy(prefix, offset, 0, length);
+    offset += length;
+  }
+  return prefix;
+}
+function nativeMessageTimestampFromBoundedPrefix(prefix) {
+  if (prefix.length === 0) return void 0;
+  const line = prefix.subarray(0, NATIVE_TAIL_MAX_RECORD_BYTES).toString("utf-8");
+  if (!/^\s*\{\s*"type"\s*:\s*"message"(?:\s*,|\s*})/.test(line)) return void 0;
+  const timestampMatch = /"timestamp"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/.exec(line);
+  if (!timestampMatch) return void 0;
+  const timestamp = Date.parse(timestampMatch[1]);
+  return Number.isFinite(timestamp) ? timestamp : void 0;
+}
+async function summarizeNativeTranscript(filepath) {
+  let title;
+  let firstUserTitle;
+  let turnCount = 0;
+  let hasAssistantReply2 = false;
+  let latestMessageAtMs;
+  const input = createReadStream(filepath, { encoding: "utf-8" });
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  for await (const line of lines) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "session_info" && typeof entry.name === "string") {
+        title = entry.name;
+        continue;
+      }
+      if (entry.type !== "message") continue;
+      const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : Number.NaN;
+      if (!Number.isNaN(timestamp)) latestMessageAtMs = timestamp;
+      if (entry.message?.role === "user") {
+        turnCount += 1;
+        firstUserTitle ??= textFromPiContent(entry.message.content).slice(0, 80) || void 0;
+      } else if (entry.message?.role === "assistant") {
+        hasAssistantReply2 = true;
+      }
+    } catch {
+    }
+  }
+  return { title, firstUserTitle, turnCount, hasAssistantReply: hasAssistantReply2, latestMessageAtMs };
+}
+
+// src/server/harness/pi-coding-agent/sessions.ts
 function sessionBaseDir(explicitRoot) {
   const explicit = explicitRoot?.trim();
   if (explicit) return resolve(explicit);
@@ -335,10 +578,9 @@ function defaultSessionDir(cwd, explicitRoot) {
   const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
   return join(sessionBaseDir(explicitRoot), safePath);
 }
-var SAFE_ID = /^[a-zA-Z0-9_-]+$/;
 var SAFE_SESSION_NAMESPACE = /^[a-zA-Z0-9_-]+$/;
 var SESSION_ROOT_ENV = "BORING_AGENT_SESSION_ROOT";
-var SUMMARY_PREFIX_BYTES = 64 * 1024;
+var SUMMARY_PREFIX_BYTES2 = 64 * 1024;
 var DEFAULT_LEGACY_WORKSPACE_ID = "default";
 var TRUSTED_LOCAL_USER_ID = "local";
 function sessionDirForNamespace(namespace, explicitRoot) {
@@ -352,7 +594,8 @@ function normalizeListOptions(options) {
   return {
     limit: options?.limit === void 0 ? void 0 : Math.max(0, options.limit),
     offset: Math.max(0, options?.offset ?? 0),
-    includeId: options?.includeId
+    includeId: options?.includeId,
+    includeEmpty: options?.includeEmpty === true
   };
 }
 var PiSessionStore = class {
@@ -360,6 +603,7 @@ var PiSessionStore = class {
   sessionDir;
   allowLegacyUnscopedAccess;
   pathDerivedLegacyAccess;
+  trustedNativeRuntimeScopeIdentity;
   prefixCache = /* @__PURE__ */ new Map();
   listInFlight = /* @__PURE__ */ new Map();
   writerTails = /* @__PURE__ */ new Map();
@@ -369,10 +613,12 @@ var PiSessionStore = class {
       this.sessionDir = options;
       this.allowLegacyUnscopedAccess = true;
       this.pathDerivedLegacyAccess = false;
+      this.trustedNativeRuntimeScopeIdentity = void 0;
       return;
     }
     this.allowLegacyUnscopedAccess = true;
     this.pathDerivedLegacyAccess = options?.sessionDir === void 0 && options?.sessionNamespace === void 0;
+    this.trustedNativeRuntimeScopeIdentity = options?.trustedNativeRuntimeScopeIdentity?.trim() || void 0;
     this.sessionDir = options?.sessionDir ?? (options?.sessionNamespace ? sessionDirForNamespace(options.sessionNamespace, options.sessionRoot) : defaultSessionDir(options?.storageCwd ?? cwd, options?.sessionRoot));
   }
   getSessionDir() {
@@ -381,9 +627,10 @@ var PiSessionStore = class {
   /** Reads the Host execution pin from authoritative session metadata. */
   async readRuntimeScopeIdentity(ctx, sessionId) {
     const filepath = await this.resolveSessionFile(sessionId, ctx);
-    const entries = parseJsonlPrefixEntries(await readJsonlPrefix(filepath));
+    const entries = parseJsonlPrefixEntries2(await readJsonlPrefix2(filepath));
     const header = entries.find((entry) => entry.type === "session");
-    if (!this.headerBelongsToCtx(header, ctx)) throw new Error(`Session not found: ${sessionId}`);
+    const directNative = isTimestampNamedPiSessionFile(filepath, header?.id ?? sessionId);
+    if (!this.headerBelongsToCtx(header, ctx, directNative)) throw new Error(`Session not found: ${sessionId}`);
     return readHeaderRuntimeScopeIdentity(header);
   }
   async list(ctx, options) {
@@ -393,7 +640,8 @@ var PiSessionStore = class {
       ctx.userId ?? null,
       normalizedOptions.limit ?? null,
       normalizedOptions.offset,
-      normalizedOptions.includeId ?? null
+      normalizedOptions.includeId ?? null,
+      normalizedOptions.includeEmpty
     ]);
     const inFlight = this.listInFlight.get(inFlightKey);
     if (inFlight) return inFlight;
@@ -411,7 +659,7 @@ var PiSessionStore = class {
     const filepaths = jsonlFiles.map((f) => join(this.sessionDir, f));
     const fileStats = await Promise.all(filepaths.map(async (filepath) => {
       try {
-        return { filepath, stat: await fsStat(filepath) };
+        return { filepath, stat: await fsStat2(filepath) };
       } catch {
         return null;
       }
@@ -424,8 +672,14 @@ var PiSessionStore = class {
     })));
     visibleFiles.sort((a, b) => b.sortMtimeMs - a.sortMtimeMs);
     const { offset, limit } = options;
-    const pageSummaries = await this.summarizeVisiblePage(visibleFiles, { ctx, offset, limit });
     const includeId = options.includeId;
+    const pageSummaries = await this.summarizeVisiblePage(visibleFiles, {
+      ctx,
+      offset,
+      limit,
+      includeId,
+      includeEmpty: options.includeEmpty
+    });
     if (!includeId || pageSummaries.some((summary) => summary.id === includeId)) return pageSummaries;
     const includeSummary = await this.summarizeIncludedSession(ctx, includeId, referencedPiFiles);
     return includeSummary ? [...pageSummaries, includeSummary] : pageSummaries;
@@ -436,7 +690,7 @@ var PiSessionStore = class {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const header = {
       type: "session",
-      version: CURRENT_SESSION_VERSION,
+      version: CURRENT_SESSION_VERSION2,
       id,
       timestamp: now,
       cwd: this.cwd,
@@ -453,27 +707,34 @@ var PiSessionStore = class {
       };
       lines.push(JSON.stringify(infoEntry));
     }
-    const filepath = join(this.sessionDir, `${id}.jsonl`);
+    const filepath = join(this.sessionDir, `${nativeSessionFilename(id, now)}`);
     await writeFile(filepath, lines.join("\n") + "\n", "utf-8");
     return {
       id,
       title: init?.title ?? "New session",
       createdAt: now,
       updatedAt: now,
-      turnCount: 0
+      turnCount: 0,
+      nativeSessionId: id,
+      hasAssistantReply: false
     };
   }
   async load(ctx, sessionId) {
     const resolved = await this.resolveSessionTranscript(ctx, sessionId);
-    const title = newestDurableTitle(resolved.sessionEntries, resolved.linkedEntries) ?? "New session";
+    const nativeSummary = resolved.directNative ? await summarizeNativeTranscript(resolved.filepath) : null;
+    const title = newestDurableTitle(resolved.sessionEntries, resolved.linkedEntries) ?? nativeSummary?.title ?? nativeSummary?.firstUserTitle ?? "New session";
     const turnCount = countUserTurns(resolved.transcriptEntries);
-    const updatedAtMs = Math.max(resolved.fileStat.mtime.getTime(), resolved.linkedMtimeMs ?? 0);
+    const updatedAtMs = nativeSummary?.latestMessageAtMs ?? Math.max(resolved.fileStat.mtime.getTime(), resolved.linkedMtimeMs ?? 0);
     return {
       id: resolved.resolvedSessionId,
       title,
       createdAt: resolved.header?.timestamp ?? resolved.fileStat.birthtime.toISOString(),
       updatedAt: new Date(updatedAtMs).toISOString(),
-      turnCount
+      turnCount,
+      ...resolved.directNative ? {
+        nativeSessionId: resolved.resolvedSessionId,
+        hasAssistantReply: hasAssistantReply(resolved.transcriptEntries)
+      } : {}
     };
   }
   /**
@@ -508,7 +769,14 @@ var PiSessionStore = class {
       throw new Error(`Session not found: ${sessionId}`);
     }
     const fileEntries = safeParseEntries(content);
-    if (fileEntries.some((e) => e.type === "ui_snapshot")) {
+    const header = fileEntries.find(
+      (e) => e.type === "session"
+    );
+    const timestampNamedNative = isTimestampNamedPiSessionFile(
+      filepath,
+      header?.id ?? sessionId
+    );
+    if (!timestampNamedNative && fileEntries.some((e) => e.type === "ui_snapshot")) {
       const compacted = fileEntries.filter((e) => e.type !== "ui_snapshot").map((e) => JSON.stringify(e)).join("\n") + "\n";
       const tmp = `${filepath}.compact-${randomUUID()}`;
       try {
@@ -519,15 +787,15 @@ var PiSessionStore = class {
         });
       }
     }
-    const header = fileEntries.find(
-      (e) => e.type === "session"
-    );
-    if (!this.headerBelongsToCtx(header, ctx)) throw new Error(`Session not found: ${sessionId}`);
+    if (!this.headerBelongsToCtx(header, ctx, timestampNamedNative)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
     const sessionEntries = fileEntries.filter(
       (e) => e.type !== "session" && e.type !== "ui_snapshot"
     );
-    const fileStat = await fsStat(filepath);
+    const fileStat = await fsStat2(filepath);
     const linkedPiFile = extractPiSessionFilePath(fileEntries);
+    const directNative = timestampNamedNative && !linkedPiFile;
     const linked = linkedPiFile && resolve(linkedPiFile) !== resolve(filepath) ? await this.readLinkedPiSession(linkedPiFile) : null;
     const linkedEntries = linked?.entries.filter(
       (e) => e.type !== "session"
@@ -542,7 +810,8 @@ var PiSessionStore = class {
       fileStat,
       linkedMtimeMs: linked?.mtime.getTime(),
       filepath,
-      ...linkedPiFile && linked ? { linkedFilepath: linkedPiFile } : {}
+      ...linkedPiFile && linked ? { linkedFilepath: linkedPiFile } : {},
+      directNative
     };
   }
   /**
@@ -550,10 +819,23 @@ var PiSessionStore = class {
    * appended through the same JSONL path under one process-local writer lock.
    */
   async rename(ctx, sessionId, title) {
-    const trimmed = title.trim();
+    const trimmed = title.replace(/[\r\n]+/g, " ").trim();
     if (!trimmed) throw new Error("Session title must not be empty");
     return await this.withWriter(sessionId, async () => {
       const resolved = await this.resolveSessionTranscript(ctx, sessionId);
+      if (resolved.directNative) {
+        try {
+          await appendVerifiedNativeRename(
+            resolved.filepath,
+            this.sessionDir,
+            this.cwd,
+            trimmed
+          );
+        } finally {
+          this.prefixCache.delete(resolved.filepath);
+        }
+        return await this.load(ctx, sessionId);
+      }
       const entry = {
         type: "session_info",
         id: randomUUID(),
@@ -591,7 +873,7 @@ var PiSessionStore = class {
   // I/O hop is introduced before createAgentSession (which would break test
   // timing when fake timers are in use). The file is tiny (metadata only).
   loadPiSessionFileSync(ctx, sessionId) {
-    if (!SAFE_ID.test(sessionId)) return null;
+    if (!SAFE_NATIVE_SESSION_ID.test(sessionId)) return null;
     try {
       const direct = join(this.sessionDir, `${sessionId}.jsonl`);
       let filepath = direct;
@@ -608,13 +890,17 @@ var PiSessionStore = class {
       }
       const entries = safeParseEntries(content);
       const header = entries.find((entry) => entry.type === "session");
-      if (!this.headerBelongsToCtx(header, ctx)) return null;
+      const directNative = isTimestampNamedPiSessionFile(filepath, header?.id ?? sessionId);
       const linkedPiFile = extractPiSessionFilePath(entries);
-      if (linkedPiFile) return linkedPiFile;
-      if (!isTimestampNamedPiSessionFile(filepath, sessionId)) return null;
+      if (!directNative) {
+        if (!this.headerBelongsToCtx(header, ctx)) return null;
+        return linkedPiFile;
+      }
+      if (this.nativeFileBelongsToCtx(header, ctx)) return filepath;
+      if (readHeaderSessionCtx(header) !== null) return null;
       const existingWrapper = this.findWrapperReferencingNativeSessionSync(filepath);
       if (existingWrapper) {
-        const existingEntries = parseJsonlPrefixEntries(readJsonlPrefixSync(existingWrapper));
+        const existingEntries = parseJsonlPrefixEntries2(readJsonlPrefixSync(existingWrapper));
         if (extractSessionHeaderId(existingEntries) !== sessionId) return null;
         const wrapperHeader = existingEntries.find((entry) => entry.type === "session");
         if (!this.headerBelongsToCtx(wrapperHeader, ctx)) return null;
@@ -627,7 +913,7 @@ var PiSessionStore = class {
     }
   }
   async loadPiSessionFile(ctx, sessionId) {
-    if (!SAFE_ID.test(sessionId)) return null;
+    if (!SAFE_NATIVE_SESSION_ID.test(sessionId)) return null;
     try {
       const direct = join(this.sessionDir, `${sessionId}.jsonl`);
       let filepath = direct;
@@ -645,20 +931,25 @@ var PiSessionStore = class {
       }
       const entries = safeParseEntries(content);
       const header = entries.find((entry) => entry.type === "session");
-      if (!this.headerBelongsToCtx(header, ctx)) return null;
+      const directNative = isTimestampNamedPiSessionFile(filepath, header?.id ?? sessionId);
       const linkedPiFile = extractPiSessionFilePath(entries);
-      if (linkedPiFile) return linkedPiFile;
-      if (!isTimestampNamedPiSessionFile(filepath, sessionId)) return null;
+      if (!directNative) {
+        if (!this.headerBelongsToCtx(header, ctx)) return null;
+        return linkedPiFile;
+      }
+      if (this.nativeFileBelongsToCtx(header, ctx)) return filepath;
+      if (readHeaderSessionCtx(header) !== null) return null;
       const existingWrapper = await this.findWrapperReferencingNativeSession(filepath);
       if (existingWrapper) {
         const wrapperSessionId = await this.readSessionFileId(existingWrapper);
         if (wrapperSessionId !== sessionId) return null;
-        const wrapperEntries = parseJsonlPrefixEntries(await readJsonlPrefix(existingWrapper));
+        const wrapperEntries = parseJsonlPrefixEntries2(await readJsonlPrefix2(existingWrapper));
         const wrapperHeader = wrapperEntries.find((entry) => entry.type === "session");
         if (!this.headerBelongsToCtx(wrapperHeader, ctx)) return null;
         return extractPiSessionFilePath(wrapperEntries);
       }
-      return await this.ensureWrapperForNativeSession(sessionId, filepath, ctx);
+      await this.ensureWrapperForNativeSession(sessionId, filepath, ctx);
+      return filepath;
     } catch {
       return null;
     }
@@ -688,12 +979,12 @@ var PiSessionStore = class {
     }
   }
   async resolveSessionFile(sessionId, ctx) {
-    if (!SAFE_ID.test(sessionId)) {
+    if (!SAFE_NATIVE_SESSION_ID.test(sessionId)) {
       throw new Error(`Session not found: ${sessionId}`);
     }
     const direct = join(this.sessionDir, `${sessionId}.jsonl`);
     try {
-      await fsStat(direct);
+      await fsStat2(direct);
       if (ctx) await this.assertFileBelongsToCtx(direct, ctx, sessionId);
       return direct;
     } catch {
@@ -708,26 +999,24 @@ var PiSessionStore = class {
       if (ctx) await this.assertFileBelongsToCtx(matchedPath, ctx, sessionId);
       return matchedPath;
     }
-    const existingWrapper = await this.findWrapperReferencingNativeSession(matchedPath);
-    if (existingWrapper) {
-      const wrapperSessionId = await this.readSessionFileId(existingWrapper);
-      if (wrapperSessionId === sessionId) {
-        if (ctx) await this.assertFileBelongsToCtx(existingWrapper, ctx, sessionId);
-        return existingWrapper;
-      }
-      throw new Error(`Session not found: ${sessionId}`);
+    if (ctx && (this.pathDerivedLegacyAccess || this.hasTrustedNativeRuntimeCapability(ctx) || await this.nativeFilePin(matchedPath) !== null)) {
+      await this.assertFileBelongsToCtx(matchedPath, ctx, sessionId);
+      return matchedPath;
     }
-    if (ctx) await this.assertFileBelongsToCtx(matchedPath, ctx, sessionId);
-    return this.ensureWrapperForNativeSession(sessionId, matchedPath, ctx);
+    if (!ctx && this.pathDerivedLegacyAccess) return matchedPath;
+    throw new Error(`Session not found: ${sessionId}`);
   }
   async assertFileBelongsToCtx(filepath, ctx, sessionId) {
-    const entries = parseJsonlPrefixEntries(await readJsonlPrefix(filepath));
+    const entries = parseJsonlPrefixEntries2(await readJsonlPrefix2(filepath));
     const header = entries.find((entry) => entry.type === "session");
-    if (!this.headerBelongsToCtx(header, ctx)) throw new Error(`Session not found: ${sessionId}`);
+    const directNative = !extractPiSessionFilePath(entries) && isTimestampNamedPiSessionFile(filepath, header?.id ?? sessionId);
+    if (!this.headerBelongsToCtx(header, ctx, directNative)) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
   }
   async readSessionFileId(filepath) {
     try {
-      const entries = parseJsonlPrefixEntries(await readJsonlPrefix(filepath));
+      const entries = parseJsonlPrefixEntries2(await readJsonlPrefix2(filepath));
       return extractSessionHeaderId(entries);
     } catch {
       return null;
@@ -759,21 +1048,25 @@ var PiSessionStore = class {
     try {
       const linkedPiFile = (await this.readPrefixCache(filepath, stat)).referencedPiFile;
       if (linkedPiFile && resolve(linkedPiFile) !== resolve(filepath)) {
-        const linkedStat = await fsStat(linkedPiFile);
+        const linkedStat = await fsStat2(linkedPiFile);
         sortMtimeMs = Math.max(sortMtimeMs, linkedStat.mtime.getTime());
       }
+      const header = parseJsonlPrefixEntries2(await readJsonlPrefix2(filepath)).find((entry) => entry.type === "session");
+      if (header && isTimestampNamedPiSessionFile(filepath, header.id)) {
+        sortMtimeMs = await latestNativeMessageTimestamp(filepath, Number(stat.size)) ?? sortMtimeMs;
+      }
     } catch {
     }
     return sortMtimeMs;
   }
   async summarizeFile(ctx, filepath, existingStat) {
     try {
-      const fileStat = existingStat ?? await fsStat(filepath);
+      const fileStat = existingStat ?? await fsStat2(filepath);
       const cached = this.cachedPrefix(filepath, fileStat);
       if (cached && "summary" in cached && cached.sessionCtx !== void 0 && this.storedCtxBelongsToCtx(cached.sessionCtx, ctx) && await this.cachedSummaryIsFresh(filepath, cached)) {
         return cached.summary ?? null;
       }
-      const content = await readJsonlPrefix(filepath);
+      const content = await readJsonlPrefix2(filepath);
       const firstNewline = content.indexOf("\n");
       if (firstNewline === -1) return null;
       const header = JSON.parse(
@@ -781,8 +1074,9 @@ var PiSessionStore = class {
       );
       if (header.type !== "session") return null;
       const sessionCtx = readHeaderSessionCtx(header);
-      if (!this.storedCtxBelongsToCtx(sessionCtx, ctx)) return null;
-      const entries = parseJsonlPrefixEntries(content);
+      const directNative = isTimestampNamedPiSessionFile(filepath, header.id);
+      if (directNative ? !this.nativeFileBelongsToCtx(header, ctx) : !this.storedCtxBelongsToCtx(sessionCtx, ctx)) return null;
+      const entries = parseJsonlPrefixEntries2(content);
       const sessionEntries = entries.filter(
         (e) => e.type !== "session"
       );
@@ -791,17 +1085,22 @@ var PiSessionStore = class {
       const linkedEntries = linked?.entries.filter(
         (e) => e.type !== "session"
       ) ?? [];
-      const title = newestDurableTitle(sessionEntries, linkedEntries) ?? firstUserMessage(linkedEntries) ?? firstUserMessage(sessionEntries) ?? "New session";
-      const turnCount = [...sessionEntries, ...linkedEntries].filter(
+      const nativeSummary = directNative ? await summarizeNativeTranscript(filepath) : null;
+      const title = newestDurableTitle(sessionEntries, linkedEntries) ?? nativeSummary?.title ?? nativeSummary?.firstUserTitle ?? firstUserMessage(linkedEntries) ?? firstUserMessage(sessionEntries) ?? "New session";
+      const turnCount = nativeSummary?.turnCount ?? [...sessionEntries, ...linkedEntries].filter(
         (e) => e.type === "message" && e.message?.role === "user"
       ).length;
-      const updatedAtMs = Math.max(fileStat.mtime.getTime(), linked?.mtime.getTime() ?? 0);
+      const updatedAtMs = nativeSummary?.latestMessageAtMs ?? Math.max(fileStat.mtime.getTime(), linked?.mtime.getTime() ?? 0);
       const summary = {
         id: header.id,
         title,
         createdAt: header.timestamp,
         updatedAt: new Date(updatedAtMs).toISOString(),
-        turnCount
+        turnCount,
+        ...nativeSummary ? {
+          nativeSessionId: header.id,
+          hasAssistantReply: nativeSummary.hasAssistantReply
+        } : {}
       };
       this.prefixCache.set(filepath, {
         mtimeMs: fileStat.mtime.getTime(),
@@ -809,7 +1108,7 @@ var PiSessionStore = class {
         referencedPiFile: linkedPiFile,
         sessionCtx,
         ...linked ? { linkedMtimeMs: linked.mtime.getTime(), linkedSize: linked.size } : {},
-        summary
+        ...!nativeSummary ? { summary } : {}
       });
       return summary;
     } catch {
@@ -826,7 +1125,7 @@ var PiSessionStore = class {
     const linkedPiFile = cached.referencedPiFile;
     if (!linkedPiFile || resolve(linkedPiFile) === resolve(filepath)) return true;
     try {
-      const linkedStat = await fsStat(linkedPiFile);
+      const linkedStat = await fsStat2(linkedPiFile);
       return cached.linkedMtimeMs === linkedStat.mtime.getTime() && cached.linkedSize === Number(linkedStat.size);
     } catch {
       return cached.linkedMtimeMs === void 0 && cached.linkedSize === void 0;
@@ -835,8 +1134,8 @@ var PiSessionStore = class {
   async readPrefixCache(filepath, fileStat) {
     const cached = this.cachedPrefix(filepath, fileStat);
     if (cached) return cached;
-    const content = await readJsonlPrefix(filepath);
-    const entries = parseJsonlPrefixEntries(content);
+    const content = await readJsonlPrefix2(filepath);
+    const entries = parseJsonlPrefixEntries2(content);
     const entry = {
       mtimeMs: fileStat.mtime.getTime(),
       size: Number(fileStat.size),
@@ -860,6 +1159,9 @@ var PiSessionStore = class {
       );
       for (const summary of summaries) {
         if (!summary) continue;
+        if (summary.turnCount === 0 && !options.includeEmpty && summary.id !== options.includeId) {
+          continue;
+        }
         if (validSeen < options.offset) {
           validSeen += 1;
           continue;
@@ -888,7 +1190,7 @@ var PiSessionStore = class {
         const filepath = join(this.sessionDir, file);
         if (resolve(filepath) === resolvedNativePath) continue;
         try {
-          const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries(readJsonlPrefixSync(filepath)));
+          const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries2(readJsonlPrefixSync(filepath)));
           if (linkedPiFile && resolve(linkedPiFile) === resolvedNativePath) return filepath;
         } catch {
         }
@@ -906,7 +1208,7 @@ var PiSessionStore = class {
       const filepath = join(this.sessionDir, file);
       if (resolve(filepath) === resolvedNativePath) continue;
       try {
-        const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries(await readJsonlPrefix(filepath)));
+        const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries2(await readJsonlPrefix2(filepath)));
         if (linkedPiFile && resolve(linkedPiFile) === resolvedNativePath) return filepath;
       } catch {
       }
@@ -937,11 +1239,11 @@ var PiSessionStore = class {
     const wrapperPath = join(this.sessionDir, `${sessionId}.jsonl`);
     if (resolve(wrapperPath) === resolve(nativePath)) return wrapperPath;
     try {
-      await fsStat(wrapperPath);
+      await fsStat2(wrapperPath);
       return wrapperPath;
     } catch {
     }
-    const entries = parseJsonlPrefixEntries(await readJsonlPrefix(nativePath));
+    const entries = parseJsonlPrefixEntries2(await readJsonlPrefix2(nativePath));
     try {
       await writeFile(
         wrapperPath,
@@ -957,7 +1259,7 @@ var PiSessionStore = class {
   async readLinkedPiSession(filepath) {
     try {
       const [fileStat, content] = await Promise.all([
-        fsStat(filepath),
+        fsStat2(filepath),
         readFile(filepath, "utf-8")
       ]);
       return { entries: safeParseEntries(content), mtime: fileStat.mtime, size: Number(fileStat.size) };
@@ -968,17 +1270,45 @@ var PiSessionStore = class {
   async readLinkedPiSessionSummary(filepath) {
     try {
       const [fileStat, content] = await Promise.all([
-        fsStat(filepath),
-        readJsonlPrefix(filepath)
+        fsStat2(filepath),
+        readJsonlPrefix2(filepath)
       ]);
-      return { entries: parseJsonlPrefixEntries(content), mtime: fileStat.mtime, size: Number(fileStat.size) };
+      return { entries: parseJsonlPrefixEntries2(content), mtime: fileStat.mtime, size: Number(fileStat.size) };
     } catch {
       return null;
     }
   }
-  headerBelongsToCtx(header, ctx) {
+  headerBelongsToCtx(header, ctx, directNative = false) {
+    if (directNative) return this.nativeFileBelongsToCtx(header, ctx);
     return header ? this.storedCtxBelongsToCtx(readHeaderSessionCtx(header), ctx) : isEmptySessionCtx(ctx);
   }
+  /**
+   * A bare Pi transcript carries no tenancy, so only a path-derived trusted
+   * local store may reach it. Boring-created native transcripts carry an exact
+   * persisted tenancy/runtime pin and remain reachable by hosted/namespaced
+   * stores without minting a compatibility wrapper.
+   */
+  nativeFileBelongsToCtx(header, ctx) {
+    const pinned = readHeaderSessionCtx(header);
+    if (pinned === null && this.hasTrustedNativeRuntimeCapability(ctx)) return true;
+    if (this.pathDerivedLegacyAccess) return this.storedCtxBelongsToCtx(pinned, ctx);
+    return pinned !== null && sameSessionCtx(pinned, ctx);
+  }
+  hasTrustedNativeRuntimeCapability(ctx) {
+    const runtimeScopeIdentity = ctx.runtimeScopeIdentity?.trim();
+    return Boolean(
+      runtimeScopeIdentity && this.trustedNativeRuntimeScopeIdentity && runtimeScopeIdentity === this.trustedNativeRuntimeScopeIdentity
+    );
+  }
+  /** The Boring tenancy pin on a native transcript, or null when unpinned. */
+  async nativeFilePin(filepath) {
+    try {
+      const entries = parseJsonlPrefixEntries2(await readJsonlPrefix2(filepath));
+      return readHeaderSessionCtx(entries.find((entry) => entry.type === "session"));
+    } catch {
+      return null;
+    }
+  }
   storedCtxBelongsToCtx(storedCtx, ctx) {
     const trustedLocalCtx = !ctx.userId || ctx.userId === TRUSTED_LOCAL_USER_ID;
     if (storedCtx === null) {
@@ -992,8 +1322,8 @@ var PiSessionStore = class {
     );
   }
 };
-async function readJsonlPrefix(filepath, maxBytes = SUMMARY_PREFIX_BYTES) {
-  const handle = await open(filepath, "r");
+async function readJsonlPrefix2(filepath, maxBytes = SUMMARY_PREFIX_BYTES2) {
+  const handle = await open4(filepath, "r");
   try {
     const buffer = Buffer.alloc(maxBytes);
     const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
@@ -1007,7 +1337,7 @@ async function readJsonlPrefix(filepath, maxBytes = SUMMARY_PREFIX_BYTES) {
     await handle.close();
   }
 }
-function readJsonlPrefixSync(filepath, maxBytes = SUMMARY_PREFIX_BYTES) {
+function readJsonlPrefixSync(filepath, maxBytes = SUMMARY_PREFIX_BYTES2) {
   const fd = openSync(filepath, "r");
   try {
     const buffer = Buffer.alloc(maxBytes);
@@ -1067,7 +1397,7 @@ function buildNativePiSessionWrapper(sessionId, cwd, piFilePath, entries, ctx) {
   const timestamp = nativeHeader?.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
   const header = {
     type: "session",
-    version: CURRENT_SESSION_VERSION,
+    version: CURRENT_SESSION_VERSION2,
     id: sessionId,
     timestamp,
     cwd: nativeHeader?.cwd ?? cwd,
@@ -1086,14 +1416,23 @@ function extractSessionHeaderId(entries) {
   const header = entries.find((entry) => entry.type === "session");
   return header?.id ?? null;
 }
+function nativeSessionFilename(sessionId, isoTimestamp) {
+  return `${isoTimestamp.replace(/[:.]/g, "-")}_${sessionId}.jsonl`;
+}
 function isTimestampNamedPiSessionFile(filepath, sessionId) {
-  return basename(filepath).endsWith(`_${sessionId}.jsonl`);
+  const filename = basename(filepath);
+  return /^\d{4}-\d{2}-\d{2}/.test(filename) && filename.endsWith(`_${sessionId}.jsonl`);
 }
 function countUserTurns(entries) {
   return entries.filter(
     (e) => e.type === "message" && e.message?.role === "user"
   ).length;
 }
+function hasAssistantReply(entries) {
+  return entries.some(
+    (entry) => entry.type === "message" && entry.message.role === "assistant"
+  );
+}
 function newestDurableTitle(wrapperEntries, nativeEntries) {
   const candidates = [
     ...wrapperEntries.flatMap((entry, offset) => entry.type === "session_info" ? [{ entry, native: 0, offset }] : []),
@@ -1110,7 +1449,7 @@ function firstUserMessage(entries) {
     if (e.type !== "message") continue;
     const msg = e.message;
     if (msg?.role !== "user") continue;
-    const text = textFromPiContent(msg.content);
+    const text = textFromPiContent2(msg.content);
     if (text) return text.slice(0, 80);
   }
 }
@@ -1129,7 +1468,7 @@ function safeParseEntries(content) {
     return results;
   }
 }
-function parseJsonlPrefixEntries(content) {
+function parseJsonlPrefixEntries2(content) {
   const entries = [];
   for (const line of content.split("\n")) {
     if (!line.trim()) continue;
@@ -1140,7 +1479,7 @@ function parseJsonlPrefixEntries(content) {
   }
   return entries;
 }
-function textFromPiContent(content) {
+function textFromPiContent2(content) {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
   return content.map((part) => {
@@ -1421,6 +1760,43 @@ function mergePiPackageSources(base = [], additional = []) {
   return compactPiPackages([...base, ...additional]);
 }
 
+// src/server/harness/pi-coding-agent/resourceSettingsManager.ts
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join2 } from "node:path";
+import { SettingsManager as SettingsManager2 } from "@mariozechner/pi-coding-agent";
+function readSettingsFileIfPresent(path) {
+  return existsSync(path) ? readFileSync2(path, "utf-8") : void 0;
+}
+function mergeInjectedProjectPackages(settingsJson, piPackages, includePackage) {
+  const settings = settingsJson ? JSON.parse(settingsJson) : {};
+  const configuredPackages = Array.isArray(settings.packages) ? settings.packages : [];
+  return JSON.stringify({
+    ...settings,
+    packages: mergePiPackageSources(configuredPackages, piPackages).filter((source) => includePackage?.(source) ?? true)
+  });
+}
+function createResourceSettingsManager(cwd, agentDir, piPackages, options = {}) {
+  if (piPackages.length === 0 && !options.includePackage) return SettingsManager2.create(cwd, agentDir);
+  const globalSettingsPath = join2(agentDir, "settings.json");
+  const projectSettingsPath = join2(cwd, ".pi", "settings.json");
+  let globalSettingsOverrideJson;
+  let projectSettingsOverrideJson;
+  const storage = {
+    withLock(scope, fn) {
+      if (scope === "global") {
+        const current2 = globalSettingsOverrideJson ?? mergeInjectedProjectPackages(readSettingsFileIfPresent(globalSettingsPath), [], options.includePackage);
+        const next2 = fn(current2);
+        if (next2 !== void 0) globalSettingsOverrideJson = next2;
+        return;
+      }
+      const current = projectSettingsOverrideJson ?? mergeInjectedProjectPackages(readSettingsFileIfPresent(projectSettingsPath), piPackages, options.includePackage);
+      const next = fn(current);
+      if (next !== void 0) projectSettingsOverrideJson = next;
+    }
+  };
+  return SettingsManager2.fromStorage(storage);
+}
+
 // src/server/harness/pi-coding-agent/createHarness.ts
 var WORKSPACE_PATHS_GUIDELINE = [
   "## Workspace paths",
@@ -1520,52 +1896,20 @@ function resolveDefaultModel(modelRegistry, override, strict) {
   return void 0;
 }
 function sessionCtxForInput(input, ctx) {
-  return normalizeSessionCtx2(input.ctx ?? { workspaceId: ctx.workspaceId }) ?? {};
+  return normalizeSessionCtx2(input.ctx ?? ctx.sessionCtx ?? { workspaceId: ctx.workspaceId }) ?? {};
 }
 function sessionCtxFromRunContext(ctx) {
-  return normalizeSessionCtx2({ workspaceId: ctx.workspaceId, userId: ctx.userId }) ?? {};
+  return normalizeSessionCtx2(ctx.sessionCtx ?? { workspaceId: ctx.workspaceId }) ?? {};
 }
 function normalizeSessionCtx2(ctx) {
-  if (!ctx?.workspaceId && !ctx?.userId) return void 0;
+  if (!ctx?.workspaceId && !ctx?.runtimeScopeIdentity) return void 0;
   return {
     ...ctx.workspaceId ? { workspaceId: ctx.workspaceId } : {},
-    ...ctx.userId ? { userId: ctx.userId } : {}
+    ...ctx.runtimeScopeIdentity ? { runtimeScopeIdentity: ctx.runtimeScopeIdentity } : {}
   };
 }
 function sessionCacheKey(sessionId, ctx) {
-  return JSON.stringify([sessionId, ctx.workspaceId ?? "", ctx.userId ?? ""]);
-}
-function readSettingsFileIfPresent(path) {
-  return existsSync(path) ? readFileSync2(path, "utf-8") : void 0;
-}
-function mergeInjectedProjectPackages(settingsJson, piPackages) {
-  const settings = settingsJson ? JSON.parse(settingsJson) : {};
-  const configuredPackages = Array.isArray(settings.packages) ? settings.packages : [];
-  return JSON.stringify({
-    ...settings,
-    packages: mergePiPackageSources(configuredPackages, piPackages)
-  });
-}
-function createResourceSettingsManager(cwd, agentDir, piPackages) {
-  if (piPackages.length === 0) return SettingsManager2.create(cwd, agentDir);
-  const globalSettingsPath = join2(agentDir, "settings.json");
-  const projectSettingsPath = join2(cwd, ".pi", "settings.json");
-  let globalSettingsOverrideJson;
-  let projectSettingsOverrideJson;
-  const storage = {
-    withLock(scope, fn) {
-      if (scope === "global") {
-        const current2 = globalSettingsOverrideJson ?? readSettingsFileIfPresent(globalSettingsPath);
-        const next2 = fn(current2);
-        if (next2 !== void 0) globalSettingsOverrideJson = next2;
-        return;
-      }
-      const current = projectSettingsOverrideJson ?? mergeInjectedProjectPackages(readSettingsFileIfPresent(projectSettingsPath), piPackages);
-      const next = fn(current);
-      if (next !== void 0) projectSettingsOverrideJson = next;
-    }
-  };
-  return SettingsManager2.fromStorage(storage);
+  return JSON.stringify([sessionId, ctx.workspaceId ?? "", ctx.runtimeScopeIdentity ?? ""]);
 }
 async function applyRequestedSessionOptions(handle, input, options = {}) {
   const requestedModel = resolveRequestedModel(handle.modelRegistry, input, { strict: options.strictModelResolution });
@@ -1662,6 +2006,8 @@ function createPiCodingAgentHarness(opts) {
   };
   refreshEffectiveResources();
   const piSessionCreations = /* @__PURE__ */ new Map();
+  const sessionGenerations = /* @__PURE__ */ new Map();
+  const generationOf = (sessionKey) => sessionGenerations.get(sessionKey) ?? 0;
   async function getOrCreatePiSession(sessionId, input, ctx) {
     const sessionCtx = sessionCtxForInput(input, ctx);
     const sessionKey = sessionCacheKey(sessionId, sessionCtx);
@@ -1676,8 +2022,18 @@ function createPiCodingAgentHarness(opts) {
       await applyRequestedSessionOptions(handle, input, { strictModelResolution: pi.strictModelResolution });
       return handle;
     }
-    const creation = createPiSession(sessionId, sessionCtx, input, ctx);
+    const generation = generationOf(sessionKey);
+    const creation = createPiSession(sessionId, sessionCtx, input, ctx).then((handle) => {
+      if (generationOf(sessionKey) === generation) return handle;
+      disposeHandleAt(sessionKey, handle);
+      throw Object.assign(new Error("session not found"), {
+        code: ErrorCode.enum.SESSION_NOT_FOUND,
+        statusCode: 404
+      });
+    });
     piSessionCreations.set(sessionKey, creation);
+    creation.catch(() => {
+    });
     try {
       return await creation;
     } finally {
@@ -1704,24 +2060,25 @@ function createPiCodingAgentHarness(opts) {
     const authStorage = AuthStorage.create();
     const modelRegistry = ModelRegistry.create(authStorage);
     registerConfiguredModelProviders(modelRegistry);
-    const savedPiFile = sessionStore.loadPiSessionFileSync(sessionCtx, sessionId);
-    let sessionManager;
-    let isNewPiSession = false;
-    const runtimeCwd = opts.runtimeCwd ?? ctx.workdir;
-    const nativeSessionDir = sessionStore.getSessionDir();
-    if (savedPiFile) {
-      try {
-        sessionManager = SessionManager.open(savedPiFile, void 0, runtimeCwd);
-      } catch {
-        sessionManager = SessionManager.create(runtimeCwd, nativeSessionDir);
-        isNewPiSession = true;
-      }
-    } else {
-      sessionManager = SessionManager.create(runtimeCwd, nativeSessionDir);
-      isNewPiSession = true;
-    }
     const resolvedModel = resolveRequestedModel(modelRegistry, input, { strict: pi.strictModelResolution });
     const model = resolvedModel ?? resolveDefaultModel(modelRegistry, pi.defaultModel, pi.strictModelResolution);
+    const savedPiFile = await sessionStore.loadPiSessionFile(sessionCtx, sessionId);
+    const runtimeCwd = opts.runtimeCwd ?? ctx.workdir;
+    if (!savedPiFile) {
+      throw Object.assign(
+        new Error(`Session not found: ${sessionId}`),
+        { code: ErrorCode.enum.SESSION_NOT_FOUND, statusCode: 404 }
+      );
+    }
+    let sessionManager;
+    try {
+      sessionManager = SessionManager2.open(savedPiFile, void 0, runtimeCwd);
+    } catch (error) {
+      throw Object.assign(
+        new Error(`failed to open pi session transcript for '${sessionId}'`),
+        { code: ErrorCode.enum.SESSION_TRANSCRIPT_UNREADABLE, statusCode: 500, cause: error }
+      );
+    }
     refreshEffectiveResources();
     const composedSystemPromptAppend = composeSystemPromptAppend(opts.systemPromptAppend);
     const dynamicPromptExtension = opts.systemPromptDynamic ? buildDynamicPromptExtension(opts.systemPromptDynamic) : void 0;
@@ -1746,6 +2103,7 @@ function createPiCodingAgentHarness(opts) {
       ...extensionFactories.length ? { extensionFactories } : {},
       ...pi.noContextFiles ? { noContextFiles: true } : {},
       ...pi.noSkills ? { noSkills: true } : {},
+      ...pi.noExtensions ? { noExtensions: true } : {},
       ...effectiveSkillPaths.length ? { additionalSkillPaths: effectiveSkillPaths } : {},
       // skillsOverride REPLACES Pi's resolved skill set, which includes
       // skills contributed by host-declared pi packages (e.g.
@@ -1771,7 +2129,7 @@ function createPiCodingAgentHarness(opts) {
       // adapted tool catalog active. Do NOT pass an explicit empty tool-name
       // allowlist: in the current Pi SDK that disables custom tools too.
       noTools: "builtin",
-      customTools: adaptToolsForPi(opts.tools, input.sessionId, opts.telemetry, () => runContextStorage.getStore()),
+      customTools: adaptToolsForPi(opts.tools, sessionId, opts.telemetry, () => runContextStorage.getStore()),
       model,
       thinkingLevel: input.thinkingLevel ?? "off",
       sessionManager,
@@ -1779,13 +2137,6 @@ function createPiCodingAgentHarness(opts) {
       modelRegistry,
       ...resourceLoader ? { resourceLoader } : {}
     });
-    if (isNewPiSession) {
-      const piFile = sessionManager.getSessionFile();
-      if (piFile) {
-        sessionStore.savePiSessionFile(sessionCtx, sessionId, piFile).catch(() => {
-        });
-      }
-    }
     const restoreFollowUpContextWrapper = rememberQueuedFollowUpRunContexts(piSession, runContextState, () => runContextStorage.getStore());
     const unsubscribePiRunContextListener = piSession.subscribe((event) => updateRunContextStateFromPiEvent(runContextState, event, (ctx2) => runContextStorage.enterWith(ctx2)));
     const unsubscribeRunContextListener = () => {
@@ -1812,34 +2163,36 @@ function createPiCodingAgentHarness(opts) {
     await Promise.all(handles.map((handle) => handle.piSession.reload()));
     return true;
   }
+  function disposeHandleAt(key, handle) {
+    handle.unsubscribeRunContextListener();
+    handle.piSession.dispose();
+    if (piSessions.get(key) === handle) piSessions.delete(key);
+  }
   function disposePiSession(sessionId, ctx) {
     if (ctx) {
       const key = sessionCacheKey(sessionId, ctx);
       const handle = piSessions.get(key);
       if (!handle) return;
-      handle.unsubscribeRunContextListener();
-      handle.piSession.dispose();
-      piSessions.delete(key);
+      disposeHandleAt(key, handle);
       return;
     }
     for (const [key, handle] of piSessions) {
       if (handle.sessionId !== sessionId) continue;
-      handle.unsubscribeRunContextListener();
-      handle.piSession.dispose();
-      piSessions.delete(key);
+      disposeHandleAt(key, handle);
     }
   }
   function piSessionHandlesFor(sessionId) {
     return [...piSessions.values()].filter((handle) => handle.sessionId === sessionId);
   }
   async function getOrCreatePiSessionForCommand(sessionId, ctx) {
-    const sessionCtx = sessionCtxFromRunContext(ctx);
-    const existing = piSessions.get(sessionCacheKey(sessionId, sessionCtx));
-    if (existing) return existing;
+    const sessionCtx = normalizeSessionCtx2(ctx.sessionCtx) ?? sessionCtxFromRunContext(ctx);
     return getOrCreatePiSession(sessionId, { sessionId, content: "", ctx: sessionCtx }, ctx);
   }
   const originalDelete = sessionStore.delete.bind(sessionStore);
   sessionStore.delete = async (ctx, sessionId) => {
+    const key = sessionCacheKey(sessionId, ctx);
+    sessionGenerations.set(key, generationOf(key) + 1);
+    await Promise.allSettled([piSessionCreations.get(key)]);
     await originalDelete(ctx, sessionId);
     disposePiSession(sessionId, ctx);
   };
@@ -1932,8 +2285,8 @@ export {
   piPackageSourceKey,
   compactPiPackages,
   mergePiPackageSources,
-  withPiHarnessDefaults,
   createResourceSettingsManager,
+  withPiHarnessDefaults,
   deriveSourcePlugin,
   createPiCodingAgentHarness
 };