@hachej/boring-agent 0.1.105 → 0.1.108

package/dist/{chunk-F2OJI2LX.js → chunk-GS4ADE34.js}

@@ -1,19 +1,18 @@
 import {
   SAFE_NATIVE_SESSION_ID,
+  compareSessionOrder,
   noopTelemetry,
   safeCapture
-} from "./chunk-4IQ4HHBG.js";
+} from "./chunk-7XAOVFSN.js";
 import {
   ErrorCode
-} from "./chunk-K25PK5EC.js";
+} from "./chunk-3JFPS2O6.js";
 
 // src/server/harness/pi-coding-agent/createHarness.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 import {
   createAgentSession,
   SessionManager as SessionManager2,
-  AuthStorage,
-  ModelRegistry,
   DefaultResourceLoader,
   getAgentDir as getAgentDir2,
   loadSkills
@@ -122,6 +121,11 @@ function createPiFollowUpQueueCompat() {
     if (nonce) seenNonces.add(nonce);
     return true;
   }
+  function rollback(text, options) {
+    const index = queue.findIndex((item) => item.text === text && item.clientNonce === options?.clientNonce && item.clientSeq === options?.clientSeq);
+    if (index >= 0) queue.splice(index, 1);
+    if (options?.clientNonce) seenNonces.delete(options.clientNonce);
+  }
   function clear(piSession, options) {
     syncWithPi(piSession);
     const removed = removeNativeFollowUp(options);
@@ -176,7 +180,7 @@ function createPiFollowUpQueueCompat() {
     if (queue.length === 0) seenNonces.clear();
     return removed;
   }
-  return { record, clear };
+  return { record, rollback, clear };
 }
 function removePiQueuedFollowUp(piSession, text, textOrdinal = 0) {
   const queue = piQueueAccess(piSession);
@@ -241,12 +245,29 @@ function matchesFollowUpSelector(item, options) {
 }
 
 // src/server/pi-chat/PiAgentSessionAdapter.ts
+var followUpQueuesBySession = /* @__PURE__ */ new WeakMap();
+function followUpQueueFor(session) {
+  const existing = followUpQueuesBySession.get(session);
+  if (existing) return existing;
+  const created = createPiFollowUpQueueCompat();
+  followUpQueuesBySession.set(session, created);
+  return created;
+}
 function normalizePromptInput(input) {
   if (typeof input === "string") return { text: input };
   return input;
 }
+var cancellationStateBySession = /* @__PURE__ */ new WeakMap();
+function cancellationStateFor(session) {
+  const existing = cancellationStateBySession.get(session);
+  if (existing) return existing;
+  const created = { abortRequested: false };
+  cancellationStateBySession.set(session, created);
+  return created;
+}
 function createPiAgentSessionAdapter(session, options = {}) {
-  const followUpQueue = createPiFollowUpQueueCompat();
+  const followUpQueue = followUpQueueFor(session);
+  const cancellationState = cancellationStateFor(session);
   const adapter = {
     readSnapshot() {
       return {
@@ -268,7 +289,25 @@ function createPiAgentSessionAdapter(session, options = {}) {
       return typeof model?.provider === "string" && typeof model?.id === "string" ? { provider: model.provider, id: model.id } : void 0;
     },
     subscribe(listener) {
-      return session.subscribe(listener);
+      return session.subscribe((event) => {
+        if (event.type === "agent_start") cancellationState.abortRequested = false;
+        if (!cancellationState.abortRequested) {
+          listener(event);
+          return;
+        }
+        if (event.type === "message_end" && event.message.role === "assistant") {
+          listener({ ...event, message: { ...event.message, stopReason: "aborted" } });
+          return;
+        }
+        if (event.type === "agent_end") {
+          const messages = event.messages.map(
+            (message, index) => index === event.messages.length - 1 && message.role === "assistant" ? { ...message, stopReason: "aborted" } : message
+          );
+          listener({ ...event, messages });
+          return;
+        }
+        listener(event);
+      });
     },
     async prompt(input) {
       const { text, options: options2 } = normalizePromptInput(input);
@@ -277,12 +316,18 @@ function createPiAgentSessionAdapter(session, options = {}) {
     async followUp(text, followUpOptions) {
       const accepted = followUpQueue.record(text, followUpOptions);
       if (!accepted) return;
-      await session.followUp(text);
+      try {
+        await session.followUp(text);
+      } catch (error) {
+        followUpQueue.rollback(text, followUpOptions);
+        throw error;
+      }
     },
     clearFollowUp(selector) {
       followUpQueue.clear(session, selector);
     },
     async abort() {
+      cancellationState.abortRequested = true;
       await session.abort();
     }
   };
@@ -296,20 +341,19 @@ function createPiAgentSessionAdapter(session, options = {}) {
 }
 
 // src/server/harness/pi-coding-agent/sessions.ts
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import {
-  readdir,
-  readFile,
+  readdir as readdir2,
+  readFile as readFile3,
   stat as fsStat2,
-  rm,
-  mkdir,
-  writeFile,
-  appendFile,
-  rename,
-  open as open4
+  rm as rm2,
+  mkdir as mkdir2,
+  writeFile as writeFile2,
+  appendFile as appendFile2,
+  open as open3
 } from "node:fs/promises";
 import { closeSync, openSync, readFileSync, readSync, readdirSync, writeFileSync } from "node:fs";
-import { join, basename, resolve } from "node:path";
+import { join as join2, basename, resolve } from "node:path";
 import { homedir } from "node:os";
 
 // src/server/config/env.ts
@@ -324,7 +368,8 @@ import {
 } 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 { randomUUID } from "node:crypto";
+import { appendFile, readFile, stat as fsStat, utimes } from "node:fs/promises";
 import {
   CURRENT_SESSION_VERSION,
   SessionManager
@@ -360,99 +405,9 @@ function completeJsonlPrefix(content, reachedLimit) {
   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 { open as open2 } from "node:fs/promises";
 import { createInterface } from "node:readline";
 
 // src/server/harness/pi-coding-agent/piSessionMessages.ts
@@ -465,14 +420,108 @@ function textFromPiContent(content) {
   }).join("");
 }
 
+// src/server/harness/pi-coding-agent/sessionTitleAuthority.ts
+var USER_SESSION_TITLE_CUSTOM_TYPE = "boring.session-title-authority";
+var MAX_USER_SESSION_TITLE_CHARACTERS = 200;
+function normalizeUserSessionTitle(title) {
+  const normalized = title.replace(/[\r\n]+/g, " ").trim();
+  if (!normalized) throw new Error("Session title must not be empty");
+  if (normalized.length > MAX_USER_SESSION_TITLE_CHARACTERS) {
+    throw new Error(`Session title must be at most ${MAX_USER_SESSION_TITLE_CHARACTERS} characters`);
+  }
+  return normalized;
+}
+function userSessionTitleData(title) {
+  return { titleSetByUser: true, title };
+}
+function isAttachedUserSessionTitleMarker(parent, marker) {
+  if (marker?.type !== "custom" || typeof marker.id !== "string" || !marker.id || marker.customType !== USER_SESSION_TITLE_CUSTOM_TYPE) return false;
+  if (parent && (typeof parent.id !== "string" || !parent.id)) return false;
+  return marker.parentId === (parent?.id ?? null);
+}
+function userSessionTitleFromSequence(parent, marker, titleEntry) {
+  if (!isAttachedUserSessionTitleMarker(parent, marker)) return void 0;
+  if (titleEntry?.type !== "session_info" || typeof titleEntry.id !== "string" || !titleEntry.id || titleEntry.parentId !== marker?.id) return void 0;
+  if (parent?.id === marker?.id || parent?.id === titleEntry.id || marker?.id === titleEntry.id) return void 0;
+  const data = marker?.data;
+  if (data?.titleSetByUser !== true || typeof data.title !== "string") return void 0;
+  try {
+    const title = normalizeUserSessionTitle(data.title);
+    return titleEntry.name === title ? title : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function createUserSessionTitleProjection() {
+  let parent;
+  let marker;
+  let previousKnown = false;
+  let markerPredecessorKnown = false;
+  let title;
+  let timestamp;
+  const reset = (predecessorKnown) => {
+    parent = void 0;
+    marker = void 0;
+    previousKnown = predecessorKnown;
+    markerPredecessorKnown = false;
+  };
+  return {
+    get title() {
+      return title;
+    },
+    get timestamp() {
+      return timestamp;
+    },
+    accept(entry) {
+      if (entry.type === "session" || entry.type === "pi_session_file") {
+        reset(true);
+        return;
+      }
+      const projected = markerPredecessorKnown ? userSessionTitleFromSequence(parent, marker, entry) : void 0;
+      if (projected) {
+        title = projected;
+        timestamp = typeof entry.timestamp === "string" ? entry.timestamp : void 0;
+      }
+      parent = marker;
+      marker = entry;
+      markerPredecessorKnown = previousKnown;
+      previousKnown = true;
+    },
+    breakSequence() {
+      reset(false);
+    }
+  };
+}
+function createUserSessionTitleEntries(input) {
+  const authority = {
+    type: "custom",
+    id: input.authorityId,
+    parentId: input.parentId,
+    timestamp: input.timestamp,
+    customType: USER_SESSION_TITLE_CUSTOM_TYPE,
+    data: userSessionTitleData(input.title)
+  };
+  return {
+    authority,
+    title: {
+      type: "session_info",
+      id: input.titleId,
+      parentId: input.authorityId,
+      timestamp: input.timestamp,
+      name: input.title
+    }
+  };
+}
+
 // 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");
+async function nativeTranscriptOrdering(filepath, size) {
+  const handle = await open2(filepath, "r");
   let end = size;
   let lineFragments = [];
+  let hasEntries = false;
   try {
     while (end > 0) {
       const start = Math.max(0, end - NATIVE_TAIL_CHUNK_BYTES);
@@ -482,11 +531,14 @@ async function latestNativeMessageTimestamp(filepath, size) {
       while (lineEnd > 0) {
         const newline = chunk.lastIndexOf(10, lineEnd - 1);
         if (newline < 0) break;
-        const timestamp = nativeMessageTimestampFromBoundedPrefix(
+        const metadata2 = nativeRecordOrderingFromBoundedPrefix(
           nativeTailRecordPrefix(chunk.subarray(newline + 1, lineEnd), lineFragments)
         );
         lineFragments = [];
-        if (timestamp !== void 0) return timestamp;
+        hasEntries ||= metadata2.hasEntry;
+        if (metadata2.latestMessageAtMs !== void 0) {
+          return { hasEntries: true, latestMessageAtMs: metadata2.latestMessageAtMs };
+        }
         lineEnd = newline;
       }
       if (lineEnd > 0) {
@@ -494,9 +546,13 @@ async function latestNativeMessageTimestamp(filepath, size) {
       }
       end = start;
     }
-    return nativeMessageTimestampFromBoundedPrefix(
+    const metadata = nativeRecordOrderingFromBoundedPrefix(
       nativeTailRecordPrefix(lineFragments.at(-1) ?? Buffer.alloc(0), lineFragments.slice(0, -1))
     );
+    return {
+      hasEntries: hasEntries || metadata.hasEntry,
+      ...metadata.latestMessageAtMs !== void 0 ? { latestMessageAtMs: metadata.latestMessageAtMs } : {}
+    };
   } finally {
     await handle.close();
   }
@@ -526,44 +582,419 @@ function nativeTailRecordPrefix(recordStart, followingFragments) {
   }
   return prefix;
 }
-function nativeMessageTimestampFromBoundedPrefix(prefix) {
-  if (prefix.length === 0) return void 0;
+function nativeRecordOrderingFromBoundedPrefix(prefix) {
+  if (prefix.length === 0) return { hasEntry: false };
   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 typeMatch = /^\s*\{\s*"type"\s*:\s*"([^"\\]+)"(?:\s*,|\s*})/.exec(line);
+  if (!typeMatch || typeMatch[1] === "session") return { hasEntry: false };
+  if (typeMatch[1] !== "message") return { hasEntry: true };
   const timestampMatch = /"timestamp"\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"/.exec(line);
-  if (!timestampMatch) return void 0;
+  if (!timestampMatch) return { hasEntry: true };
   const timestamp = Date.parse(timestampMatch[1]);
-  return Number.isFinite(timestamp) ? timestamp : void 0;
+  return Number.isFinite(timestamp) ? { hasEntry: true, latestMessageAtMs: timestamp } : { hasEntry: true };
 }
-async function summarizeNativeTranscript(filepath) {
+function createSessionTranscriptAccumulator() {
   let title;
+  let titleTimestamp;
   let firstUserTitle;
+  let entryCount = 0;
   let turnCount = 0;
-  let hasAssistantReply2 = false;
+  let hasAssistantReply = false;
   let latestMessageAtMs;
+  const userTitle = createUserSessionTitleProjection();
+  const authorityMarkerIds = /* @__PURE__ */ new Set();
+  return {
+    acceptLine(line, committed = true) {
+      if (!line.trim()) return void 0;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        userTitle.breakSequence();
+        return void 0;
+      }
+      if (!entry || typeof entry !== "object" || typeof entry.type !== "string") {
+        userTitle.breakSequence();
+        return void 0;
+      }
+      const record = entry;
+      if (record.type === "custom" && record.customType === USER_SESSION_TITLE_CUSTOM_TYPE && typeof record.id === "string") authorityMarkerIds.add(record.id);
+      if (committed) userTitle.accept(entry);
+      else userTitle.breakSequence();
+      if (entry.type !== "session") entryCount += 1;
+      if (entry.type === "session_info" && typeof entry.name === "string") {
+        if (!authorityMarkerIds.has(entry.parentId ?? "")) {
+          title = entry.name;
+          titleTimestamp = typeof entry.timestamp === "string" ? entry.timestamp : void 0;
+        }
+      } else if (entry.type === "message") {
+        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") {
+          hasAssistantReply = true;
+        }
+      }
+      return entry;
+    },
+    summary() {
+      return {
+        ...title ? { title } : {},
+        ...titleTimestamp ? { titleTimestamp } : {},
+        ...userTitle.title ? { userTitle: userTitle.title } : {},
+        ...userTitle.timestamp ? { userTitleTimestamp: userTitle.timestamp } : {},
+        ...firstUserTitle ? { firstUserTitle } : {},
+        entryCount,
+        turnCount,
+        hasAssistantReply,
+        ...latestMessageAtMs !== void 0 ? { latestMessageAtMs } : {}
+      };
+    }
+  };
+}
+function parseSessionTranscript(content) {
+  const accumulator = createSessionTranscriptAccumulator();
+  const entries = [];
+  const physicalLines = content.split("\n");
+  const lastIndex = physicalLines.length - 1;
+  for (const [index, line] of physicalLines.entries()) {
+    const entry = accumulator.acceptLine(line, index < lastIndex);
+    if (entry) entries.push(entry);
+  }
+  return { entries, summary: accumulator.summary() };
+}
+async function transcriptEndsWithNewline(filepath) {
+  const handle = await open2(filepath, "r");
+  try {
+    const { size } = await handle.stat();
+    if (size === 0) return true;
+    const byte = Buffer.allocUnsafe(1);
+    const { bytesRead } = await handle.read(byte, 0, 1, size - 1);
+    return bytesRead === 1 && byte[0] === 10;
+  } finally {
+    await handle.close();
+  }
+}
+async function summarizeSessionTranscript(filepath) {
+  const accumulator = createSessionTranscriptAccumulator();
+  const endsWithNewline = await transcriptEndsWithNewline(filepath);
   const input = createReadStream(filepath, { encoding: "utf-8" });
   const lines = createInterface({ input, crlfDelay: Infinity });
+  let pending;
   for await (const line of lines) {
+    if (pending !== void 0) accumulator.acceptLine(pending);
+    pending = line;
+  }
+  if (pending !== void 0) accumulator.acceptLine(pending, endsWithNewline);
+  return accumulator.summary();
+}
+
+// src/server/harness/pi-coding-agent/nativeSessionRename.ts
+var SESSION_TITLE_MAX_APPEND_ATTEMPTS = 3;
+var SESSION_TITLE_RETRY_CUSTOM_TYPE = "boring.session-title-retry";
+function sameSnapshot(a, b) {
+  return a.dev === b.dev && a.ino === b.ino && a.size === b.size && a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs;
+}
+async function readStableFile(filepath) {
+  const before = await fsStat(filepath);
+  const content = await readFile(filepath, "utf-8");
+  const after = await fsStat(filepath);
+  return sameSnapshot(before, after) ? { before, after, content } : null;
+}
+async function restoreVerifiedRenameMtime(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 {
+  }
+}
+function committedPhysicalLines(content) {
+  const lines = content.split("\n");
+  if (!content.endsWith("\n")) lines.pop();
+  return lines;
+}
+function hasVerifiedTitleSequence(content, append, title) {
+  let parent;
+  let marker;
+  let previousKnown = false;
+  let markerPredecessorKnown = false;
+  for (const line of committedPhysicalLines(content)) {
     if (!line.trim()) continue;
+    let entry;
     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;
-      }
+      entry = JSON.parse(line);
     } catch {
+      parent = void 0;
+      marker = void 0;
+      previousKnown = false;
+      markerPredecessorKnown = false;
+      continue;
+    }
+    if (!entry || typeof entry !== "object" || typeof entry.type !== "string") {
+      parent = void 0;
+      marker = void 0;
+      previousKnown = false;
+      markerPredecessorKnown = false;
+      continue;
+    }
+    if (entry.type === "session" || entry.type === "pi_session_file") {
+      parent = void 0;
+      marker = void 0;
+      previousKnown = true;
+      markerPredecessorKnown = false;
+      continue;
+    }
+    if (entry.id === append.title.id && marker?.id === append.authority.id && markerPredecessorKnown && marker.parentId === append.authority.parentId && entry.parentId === append.title.parentId && userSessionTitleFromSequence(parent, marker, entry) === title) return true;
+    parent = marker;
+    marker = entry;
+    markerPredecessorKnown = previousKnown;
+    previousKnown = true;
+  }
+  return false;
+}
+async function verifyTitleSequence(filepath, append, title) {
+  const snapshot = await readStableFile(filepath);
+  if (!snapshot || !hasVerifiedTitleSequence(snapshot.content, append, title)) return null;
+  const parsed = parseSessionTranscript(snapshot.content);
+  const tailId = parsed.entries.filter((entry) => entry.type !== "session" && typeof entry.id === "string").at(-1)?.id ?? null;
+  return { stat: snapshot.after, content: snapshot.content, tailId };
+}
+function isExactRenameOnlyAppend(origin, verifiedContent, append) {
+  const prefix = `${origin.content}${origin.content.endsWith("\n") ? "" : "\n"}`;
+  if (!verifiedContent.startsWith(prefix)) return false;
+  const suffix = verifiedContent.slice(prefix.length);
+  const lines = suffix.split("\n");
+  if (lines.length !== 3 || lines[2] !== "" || !lines[0]?.trim() || !lines[1]?.trim()) return false;
+  try {
+    const entries = lines.slice(0, 2).map((line) => JSON.parse(line));
+    return entries[0]?.id === append.authority.id && entries[1]?.id === append.title.id;
+  } catch {
+    return false;
+  }
+}
+function physicalTail(content) {
+  const endsWithNewline = content.length === 0 || content.endsWith("\n");
+  const line = content.split("\n").reverse().find((candidate) => candidate.trim());
+  if (!line) return { endsWithNewline, valid: true, parentId: null };
+  try {
+    const entry = JSON.parse(line);
+    if (!entry || typeof entry !== "object" || typeof entry.type !== "string") {
+      return { endsWithNewline, valid: false, parentId: null };
+    }
+    if (entry.type === "session" || entry.type === "pi_session_file") {
+      return { endsWithNewline, valid: true, parentId: null };
+    }
+    return typeof entry.id === "string" && entry.id ? { endsWithNewline, valid: true, parentId: entry.id } : { endsWithNewline, valid: false, parentId: null };
+  } catch {
+    return { endsWithNewline, valid: false, parentId: null };
+  }
+}
+function latestConcurrentEntryId(manager, staleRenameIds) {
+  for (const entry of manager.getEntries().reverse()) {
+    if (!staleRenameIds.has(entry.id)) return entry.id;
+  }
+  return null;
+}
+function sessionTitleLockedError(message = "session changed while renaming; retry") {
+  return Object.assign(new Error(message), {
+    code: ErrorCode.enum.SESSION_LOCKED,
+    statusCode: 409,
+    retryable: true
+  });
+}
+function sessionTranscriptUnreadableError(message) {
+  return Object.assign(new Error(message), {
+    code: ErrorCode.enum.SESSION_TRANSCRIPT_UNREADABLE,
+    statusCode: 500,
+    retryable: false
+  });
+}
+async function repairNativeTerminalNewline(filepath) {
+  const snapshot = await readStableFile(filepath);
+  if (!snapshot) return false;
+  const tail = physicalTail(snapshot.content);
+  if (tail.endsWithNewline) return true;
+  if (!tail.valid) throw sessionTitleLockedError("native session has an incomplete transcript record");
+  await appendFile(filepath, "\n");
+  const repaired = await readStableFile(filepath);
+  return Boolean(repaired?.content.endsWith("\n"));
+}
+async function appendVerifiedNativeRename(filepath, sessionDir, cwd, title) {
+  const staleRenameIds = /* @__PURE__ */ new Set();
+  let renameOnlyOrigin;
+  for (let attempt = 0; attempt < SESSION_TITLE_MAX_APPEND_ATTEMPTS; attempt += 1) {
+    const attemptOrigin = await readStableFile(filepath);
+    if (!attemptOrigin) continue;
+    if (attempt === 0) renameOnlyOrigin = attemptOrigin;
+    const header = parseJsonlPrefixEntries(await readJsonlPrefix(filepath)).find(
+      (entry) => entry.type === "session"
+    );
+    if (header?.version !== CURRENT_SESSION_VERSION) {
+      throw sessionTitleLockedError("This native session was created by an unsupported Pi version and cannot be renamed.");
+    }
+    if (!await repairNativeTerminalNewline(filepath)) continue;
+    const committed = await readStableFile(filepath);
+    if (!committed) continue;
+    if (!physicalTail(committed.content).valid) {
+      throw sessionTranscriptUnreadableError("native session contains a malformed transcript record");
+    }
+    const manager = SessionManager.open(filepath, sessionDir, cwd);
+    if (staleRenameIds.size > 0) {
+      const concurrentLeaf = latestConcurrentEntryId(manager, staleRenameIds);
+      if (!concurrentLeaf) break;
+      manager.branch(concurrentLeaf);
+      manager.appendCustomEntry(SESSION_TITLE_RETRY_CUSTOM_TYPE, {});
+    }
+    const beforeAppend = await readStableFile(filepath);
+    if (!beforeAppend || !beforeAppend.content.endsWith("\n")) continue;
+    const tail = physicalTail(beforeAppend.content);
+    const authorityParentId = manager.getLeafId();
+    if (!tail.valid || tail.parentId !== authorityParentId) continue;
+    const authorityId = manager.appendCustomEntry(
+      USER_SESSION_TITLE_CUSTOM_TYPE,
+      userSessionTitleData(title)
+    );
+    const titleId = manager.appendSessionInfo(title);
+    const append = {
+      authority: { id: authorityId, parentId: authorityParentId },
+      title: { id: titleId, parentId: authorityId }
+    };
+    staleRenameIds.add(authorityId);
+    staleRenameIds.add(titleId);
+    const verified = await verifyTitleSequence(filepath, append, title);
+    if (!verified) continue;
+    if (attempt === 0 && verified.tailId === titleId && renameOnlyOrigin && isExactRenameOnlyAppend(renameOnlyOrigin, verified.content, append)) {
+      await restoreVerifiedRenameMtime(filepath, renameOnlyOrigin.before, Number(verified.stat.size));
     }
+    return;
+  }
+  throw sessionTitleLockedError();
+}
+function wrapperPredecessor(content) {
+  const tail = physicalTail(content);
+  if (!tail.valid) {
+    if (!tail.endsWithNewline) throw sessionTitleLockedError("session has an incomplete transcript record");
+    throw sessionTranscriptUnreadableError("session contains a malformed transcript record");
+  }
+  return {
+    parentId: tail.parentId,
+    separator: tail.endsWithNewline ? "" : "\n"
+  };
+}
+async function appendVerifiedWrapperRename(filepath, title) {
+  let renameOnlyStart;
+  for (let attempt = 0; attempt < SESSION_TITLE_MAX_APPEND_ATTEMPTS; attempt += 1) {
+    const snapshot = await readStableFile(filepath);
+    if (!snapshot) continue;
+    renameOnlyStart ??= snapshot.before;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const predecessor = wrapperPredecessor(snapshot.content);
+    const pair = createUserSessionTitleEntries({
+      title,
+      parentId: predecessor.parentId,
+      timestamp,
+      authorityId: randomUUID(),
+      titleId: randomUUID()
+    });
+    const append = {
+      authority: { id: pair.authority.id, parentId: pair.authority.parentId },
+      title: { id: pair.title.id, parentId: pair.title.parentId }
+    };
+    const records = [pair.authority, pair.title].map((entry) => JSON.stringify(entry)).join("\n");
+    const payload = `${predecessor.separator}${records}
+`;
+    await appendFile(filepath, payload);
+    const verified = await verifyTitleSequence(filepath, append, title);
+    if (!verified) continue;
+    const exactSize = Number(snapshot.after.size) + Buffer.byteLength(payload);
+    if (attempt === 0 && Number(verified.stat.size) === exactSize && renameOnlyStart) {
+      await restoreVerifiedRenameMtime(filepath, renameOnlyStart, exactSize);
+    }
+    return;
+  }
+  throw sessionTitleLockedError();
+}
+function fileTimeSeconds(milliseconds) {
+  const seconds = milliseconds / 1e3;
+  return Number.isFinite(seconds) ? seconds : void 0;
+}
+
+// src/server/harness/pi-coding-agent/sessionArchiveIndex.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { mkdir, readFile as readFile2, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+var SESSION_ARCHIVE_DIRECTORY_NAME = ".archive";
+var ARCHIVE_MARKER_VERSION = 1;
+var ARCHIVE_MARKER_SUFFIX = ".json";
+function archiveDirectory(sessionDir) {
+  return join(sessionDir, SESSION_ARCHIVE_DIRECTORY_NAME);
+}
+function markerFilename(sessionId) {
+  return `${Buffer.from(sessionId, "utf8").toString("base64url")}${ARCHIVE_MARKER_SUFFIX}`;
+}
+function markerPath(sessionDir, sessionId) {
+  return join(archiveDirectory(sessionDir), markerFilename(sessionId));
+}
+function parseMarker(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    return parsed.version === ARCHIVE_MARKER_VERSION && typeof parsed.sessionId === "string" && parsed.sessionId.length > 0 && typeof parsed.archivedAt === "string" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+async function readArchivedSessionIds(sessionDir) {
+  const directory = archiveDirectory(sessionDir);
+  const files = await readdir(directory).catch(() => []);
+  const ids = /* @__PURE__ */ new Set();
+  await Promise.all(files.filter((file) => file.endsWith(ARCHIVE_MARKER_SUFFIX)).map(async (file) => {
+    const marker = parseMarker(await readFile2(join(directory, file), "utf8").catch(() => ""));
+    if (marker && file === markerFilename(marker.sessionId)) ids.add(marker.sessionId);
+  }));
+  return ids;
+}
+async function writeSessionArchived(sessionDir, sessionId, archived, now = /* @__PURE__ */ new Date()) {
+  const target = markerPath(sessionDir, sessionId);
+  if (!archived) {
+    try {
+      await rm(target);
+      return true;
+    } catch (error) {
+      if (error.code === "ENOENT") return false;
+      throw error;
+    }
+  }
+  await mkdir(archiveDirectory(sessionDir), { recursive: true });
+  const marker = {
+    version: ARCHIVE_MARKER_VERSION,
+    sessionId,
+    archivedAt: now.toISOString()
+  };
+  const tmp = `${target}.${randomUUID2()}.tmp`;
+  try {
+    await writeFile(tmp, `${JSON.stringify(marker)}
+`, { encoding: "utf8", flag: "wx" });
+    await rename(tmp, target);
+    return true;
+  } catch (error) {
+    await rm(tmp, { force: true }).catch(() => {
+    });
+    throw error;
   }
-  return { title, firstUserTitle, turnCount, hasAssistantReply: hasAssistantReply2, latestMessageAtMs };
+}
+async function forgetArchivedSession(sessionDir, sessionId) {
+  await rm(markerPath(sessionDir, sessionId), { force: true });
 }
 
 // src/server/harness/pi-coding-agent/sessions.ts
@@ -593,31 +1024,37 @@ function sessionBaseDir(explicitRoot) {
   const explicit = explicitRoot?.trim();
   if (explicit) return resolve(explicit);
   const configured = getEnv(SESSION_ROOT_ENV)?.trim();
-  return configured ? resolve(configured) : join(homedir(), ".pi", "agent", "sessions");
+  return configured ? resolve(configured) : join2(homedir(), ".pi", "agent", "sessions");
 }
 function defaultSessionDir(cwd, explicitRoot) {
   if (explicitRoot && cwd.trim().length === 0) return sessionBaseDir(explicitRoot);
   const safePath = `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-  return join(sessionBaseDir(explicitRoot), safePath);
+  return join2(sessionBaseDir(explicitRoot), safePath);
 }
 var SAFE_SESSION_NAMESPACE = /^[a-zA-Z0-9_-]+$/;
 var SESSION_ROOT_ENV = "BORING_AGENT_SESSION_ROOT";
 var SUMMARY_PREFIX_BYTES2 = 64 * 1024;
+var MAX_CONCURRENT_SESSION_SUMMARIES = 4;
 var DEFAULT_LEGACY_WORKSPACE_ID = "default";
 var TRUSTED_LOCAL_USER_ID = "local";
+function withArchivedFlag(summary, archivedIds) {
+  return archivedIds.has(summary.id) ? { ...summary, archived: true } : summary;
+}
 function sessionDirForNamespace(namespace, explicitRoot) {
   const safeNamespace = namespace.trim();
   if (!SAFE_SESSION_NAMESPACE.test(safeNamespace)) {
     throw new Error("session namespace must contain only letters, numbers, underscores, and dashes");
   }
-  return join(sessionBaseDir(explicitRoot), safeNamespace);
+  return join2(sessionBaseDir(explicitRoot), safeNamespace);
 }
 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,
-    includeEmpty: options?.includeEmpty === true
+    includeEmpty: options?.includeEmpty === true,
+    archived: options?.archived ?? "all",
+    after: options?.after
   };
 }
 var PiSessionStore = class {
@@ -663,7 +1100,9 @@ var PiSessionStore = class {
       normalizedOptions.limit ?? null,
       normalizedOptions.offset,
       normalizedOptions.includeId ?? null,
-      normalizedOptions.includeEmpty
+      normalizedOptions.includeEmpty,
+      normalizedOptions.archived,
+      normalizedOptions.after ?? null
     ]);
     const inFlight = this.listInFlight.get(inFlightKey);
     if (inFlight) return inFlight;
@@ -676,9 +1115,9 @@ var PiSessionStore = class {
     }
   }
   async listUncached(ctx, options) {
-    const files = await readdir(this.sessionDir).catch(() => []);
+    const files = await readdir2(this.sessionDir).catch(() => []);
     const jsonlFiles = files.filter((f) => f.endsWith(".jsonl"));
-    const filepaths = jsonlFiles.map((f) => join(this.sessionDir, f));
+    const filepaths = jsonlFiles.map((f) => join2(this.sessionDir, f));
     const fileStats = await Promise.all(filepaths.map(async (filepath) => {
       try {
         return { filepath, stat: await fsStat2(filepath) };
@@ -689,23 +1128,35 @@ var PiSessionStore = class {
     const existingFiles = fileStats.filter((item) => item !== null);
     const referencedPiFiles = await this.referencedPiFiles(existingFiles);
     const visibleFiles = await Promise.all(existingFiles.filter(({ filepath }) => !referencedPiFiles.has(resolve(filepath))).map(async (file) => ({ ...file, ...await this.sessionSortKey(file) })));
-    visibleFiles.sort((a, b) => b.sortMtimeMs - a.sortMtimeMs || a.sortId.localeCompare(b.sortId));
+    visibleFiles.sort((a, b) => compareSessionOrder(
+      [a.orderingUpdatedAtMs, "", a.sortId],
+      [b.orderingUpdatedAtMs, "", b.sortId]
+    ));
     const { offset, limit } = options;
     const includeId = options.includeId;
-    const pageSummaries = await this.summarizeVisiblePage(visibleFiles, {
+    const archivedIds = await readArchivedSessionIds(this.sessionDir);
+    const after = options.after;
+    const afterFiles = after ? visibleFiles.filter((file) => compareSessionOrder(
+      [file.orderingUpdatedAtMs, after.agentTypeId, file.sortId],
+      after.position
+    ) > 0) : visibleFiles;
+    const filteredFiles = options.archived === "all" ? afterFiles : afterFiles.filter((file) => archivedIds.has(file.sortId) === (options.archived === "archived"));
+    const pageSummaries = await this.summarizeVisiblePage(filteredFiles, {
       ctx,
       offset,
       limit,
       includeId,
-      includeEmpty: options.includeEmpty
+      includeEmpty: options.includeEmpty,
+      archivedIds
     });
     if (!includeId || pageSummaries.some((summary) => summary.id === includeId)) return pageSummaries;
     const includeSummary = await this.summarizeIncludedSession(ctx, includeId, referencedPiFiles);
-    return includeSummary ? [...pageSummaries, includeSummary] : pageSummaries;
+    return includeSummary ? [...pageSummaries, withArchivedFlag(includeSummary, archivedIds)] : pageSummaries;
   }
   async create(ctx, init) {
-    await mkdir(this.sessionDir, { recursive: true });
-    const id = randomUUID();
+    const manualTitle = init?.title !== void 0 ? normalizeUserSessionTitle(init.title) : void 0;
+    await mkdir2(this.sessionDir, { recursive: true });
+    const id = randomUUID3();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const header = {
       type: "session",
@@ -716,21 +1167,21 @@ var PiSessionStore = class {
       boringSessionCtx: normalizeSessionCtx(ctx) ?? {}
     };
     const lines = [JSON.stringify(header)];
-    if (init?.title) {
-      const infoEntry = {
-        type: "session_info",
-        id: randomUUID(),
+    if (manualTitle) {
+      const pair = createUserSessionTitleEntries({
+        title: manualTitle,
         parentId: null,
         timestamp: now,
-        name: init.title
-      };
-      lines.push(JSON.stringify(infoEntry));
+        authorityId: randomUUID3(),
+        titleId: randomUUID3()
+      });
+      lines.push(JSON.stringify(pair.authority), JSON.stringify(pair.title));
     }
-    const filepath = join(this.sessionDir, `${nativeSessionFilename(id, now)}`);
-    await writeFile(filepath, lines.join("\n") + "\n", "utf-8");
+    const filepath = join2(this.sessionDir, `${nativeSessionFilename(id, now)}`);
+    await writeFile2(filepath, lines.join("\n") + "\n", "utf-8");
     return {
       id,
-      title: init?.title ?? "New session",
+      title: manualTitle ?? "New session",
       createdAt: now,
       updatedAt: now,
       turnCount: 0,
@@ -738,23 +1189,39 @@ var PiSessionStore = class {
       hasAssistantReply: false
     };
   }
+  /**
+   * Visibility only. Resolve tenancy and build the receipt through the bounded
+   * listing projection; never call `load`, whose legacy compatibility path may
+   * compact ui_snapshot entries and therefore mutate transcript bytes/mtime.
+   */
+  async setArchived(ctx, sessionId, archived) {
+    const filepath = await this.resolveSessionFile(sessionId, ctx);
+    const summary = await this.summarizeFile(ctx, filepath);
+    if (!summary) throw new Error(`Session not found: ${sessionId}`);
+    await writeSessionArchived(this.sessionDir, summary.id, archived);
+    try {
+      await this.resolveSessionFile(summary.id, ctx);
+    } catch (error) {
+      await forgetArchivedSession(this.sessionDir, summary.id);
+      throw error;
+    }
+    return archived ? { ...summary, archived: true } : summary;
+  }
   async load(ctx, sessionId) {
     const resolved = await this.resolveSessionTranscript(ctx, sessionId);
-    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 = nativeSummary?.latestMessageAtMs ?? Math.max(resolved.fileStat.mtime.getTime(), resolved.linkedMtimeMs ?? 0);
-    return {
+    const title = projectedTranscriptTitle(resolved.sessionSummary, resolved.linkedSummary) ?? "New session";
+    const updatedAtMs = resolved.transcriptSummary.latestMessageAtMs ?? Math.max(resolved.fileStat.mtime.getTime(), resolved.linkedMtimeMs ?? 0);
+    return withArchivedFlag({
       id: resolved.resolvedSessionId,
       title,
       createdAt: resolved.header?.timestamp ?? resolved.fileStat.birthtime.toISOString(),
       updatedAt: new Date(updatedAtMs).toISOString(),
-      turnCount,
+      turnCount: resolved.transcriptSummary.turnCount,
       ...resolved.directNative ? {
         nativeSessionId: resolved.resolvedSessionId,
-        hasAssistantReply: hasAssistantReply(resolved.transcriptEntries)
+        hasAssistantReply: resolved.transcriptSummary.hasAssistantReply
       } : {}
-    };
+    }, await readArchivedSessionIds(this.sessionDir));
   }
   /**
    * Returns the persisted pi message objects in file order so callers can run
@@ -787,11 +1254,12 @@ var PiSessionStore = class {
     const filepath = await this.resolveSessionFile(sessionId, ctx);
     let content;
     try {
-      content = await readFile(filepath, "utf-8");
+      content = await readFile3(filepath, "utf-8");
     } catch {
       throw new Error(`Session not found: ${sessionId}`);
     }
-    const fileEntries = safeParseEntries(content);
+    const parsedFile = parseSessionTranscript(content);
+    const fileEntries = parsedFile.entries;
     const header = fileEntries.find(
       (e) => e.type === "session"
     );
@@ -799,17 +1267,6 @@ var PiSessionStore = class {
       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 {
-        await writeFile(tmp, compacted, "utf-8");
-        await rename(tmp, filepath);
-      } catch {
-        await rm(tmp, { force: true }).catch(() => {
-        });
-      }
-    }
     if (!this.headerBelongsToCtx(header, ctx, timestampNamedNative)) {
       throw new Error(`Session not found: ${sessionId}`);
     }
@@ -823,17 +1280,18 @@ var PiSessionStore = class {
     const linkedEntries = linked?.entries.filter(
       (e) => e.type !== "session"
     ) ?? [];
-    const transcriptEntries = linkedEntries.length > 0 ? linkedEntries : sessionEntries;
+    const transcriptSummary = selectTranscriptSummary(parsedFile.summary, linked?.summary);
+    const transcriptEntries = transcriptSummary === linked?.summary ? linkedEntries : sessionEntries;
     return {
       resolvedSessionId: header?.id ?? sessionId,
       header,
-      sessionEntries,
-      linkedEntries,
       transcriptEntries,
+      sessionSummary: parsedFile.summary,
+      ...linked ? { linkedSummary: linked.summary } : {},
+      transcriptSummary,
       fileStat,
-      linkedMtimeMs: linked?.mtime.getTime(),
+      linkedMtimeMs: linked?.mtimeMs,
       filepath,
-      ...linkedPiFile && linked ? { linkedFilepath: linkedPiFile } : {},
       directNative
     };
   }
@@ -842,8 +1300,7 @@ var PiSessionStore = class {
    * appended through the same JSONL path under one process-local writer lock.
    */
   async rename(ctx, sessionId, title) {
-    const trimmed = title.replace(/[\r\n]+/g, " ").trim();
-    if (!trimmed) throw new Error("Session title must not be empty");
+    const trimmed = normalizeUserSessionTitle(title);
     return await this.withWriter(sessionId, async () => {
       const resolved = await this.resolveSessionTranscript(ctx, sessionId);
       if (resolved.directNative) {
@@ -859,20 +1316,8 @@ var PiSessionStore = class {
         }
         return await this.load(ctx, sessionId);
       }
-      const entry = {
-        type: "session_info",
-        id: randomUUID(),
-        parentId: null,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        name: trimmed
-      };
-      const line = `${JSON.stringify(entry)}
-`;
-      const targets = [resolved.filepath, resolved.linkedFilepath].filter((path) => Boolean(path));
-      for (const filepath of targets) {
-        await appendFile(filepath, line);
-        this.prefixCache.delete(filepath);
-      }
+      await appendVerifiedWrapperRename(resolved.filepath, trimmed);
+      this.prefixCache.delete(resolved.filepath);
       return await this.load(ctx, sessionId);
     });
   }
@@ -898,7 +1343,7 @@ var PiSessionStore = class {
   loadPiSessionFileSync(ctx, sessionId) {
     if (!SAFE_NATIVE_SESSION_ID.test(sessionId)) return null;
     try {
-      const direct = join(this.sessionDir, `${sessionId}.jsonl`);
+      const direct = join2(this.sessionDir, `${sessionId}.jsonl`);
       let filepath = direct;
       let content;
       try {
@@ -908,7 +1353,7 @@ var PiSessionStore = class {
           (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
         );
         if (files.length === 0) return null;
-        filepath = join(this.sessionDir, files[0]);
+        filepath = join2(this.sessionDir, files[0]);
         content = readFileSync(filepath, "utf-8");
       }
       const entries = safeParseEntries(content);
@@ -938,19 +1383,19 @@ var PiSessionStore = class {
   async loadPiSessionFile(ctx, sessionId) {
     if (!SAFE_NATIVE_SESSION_ID.test(sessionId)) return null;
     try {
-      const direct = join(this.sessionDir, `${sessionId}.jsonl`);
+      const direct = join2(this.sessionDir, `${sessionId}.jsonl`);
       let filepath = direct;
       let content;
       try {
-        content = await readFile(direct, "utf-8");
+        content = await readFile3(direct, "utf-8");
       } catch {
-        const files = await readdir(this.sessionDir).catch(() => []);
+        const files = await readdir2(this.sessionDir).catch(() => []);
         const match = files.find(
           (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
         );
         if (!match) return null;
-        filepath = join(this.sessionDir, match);
-        content = await readFile(filepath, "utf-8");
+        filepath = join2(this.sessionDir, match);
+        content = await readFile3(filepath, "utf-8");
       }
       const entries = safeParseEntries(content);
       const header = entries.find((entry) => entry.type === "session");
@@ -984,7 +1429,7 @@ var PiSessionStore = class {
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       path: piFilePath
     });
-    await appendFile(filepath, entry + "\n");
+    await appendFile2(filepath, entry + "\n");
   }
   async delete(ctx, sessionId) {
     const filepath = await this.resolveSessionFile(sessionId, ctx).catch(
@@ -994,30 +1439,31 @@ var PiSessionStore = class {
     const fileSessionId = await this.readSessionFileId(filepath);
     if (fileSessionId && fileSessionId !== sessionId) return;
     const linkedPiFile = await this.linkedPiFileFor(filepath);
-    await rm(filepath, { force: true });
+    await rm2(filepath, { force: true });
     this.prefixCache.delete(filepath);
     if (linkedPiFile && resolve(linkedPiFile) !== resolve(filepath)) {
-      await rm(linkedPiFile, { force: true });
+      await rm2(linkedPiFile, { force: true });
       this.prefixCache.delete(linkedPiFile);
     }
+    await forgetArchivedSession(this.sessionDir, fileSessionId ?? sessionId);
   }
   async resolveSessionFile(sessionId, ctx) {
     if (!SAFE_NATIVE_SESSION_ID.test(sessionId)) {
       throw new Error(`Session not found: ${sessionId}`);
     }
-    const direct = join(this.sessionDir, `${sessionId}.jsonl`);
+    const direct = join2(this.sessionDir, `${sessionId}.jsonl`);
     try {
       await fsStat2(direct);
       if (ctx) await this.assertFileBelongsToCtx(direct, ctx, sessionId);
       return direct;
     } catch {
     }
-    const files = await readdir(this.sessionDir).catch(() => []);
+    const files = await readdir2(this.sessionDir).catch(() => []);
     const match = files.find(
       (f) => f.endsWith(`_${sessionId}.jsonl`) || f === `${sessionId}.jsonl`
     );
     if (!match) throw new Error(`Session not found: ${sessionId}`);
-    const matchedPath = join(this.sessionDir, match);
+    const matchedPath = join2(this.sessionDir, match);
     if (!isTimestampNamedPiSessionFile(matchedPath, sessionId)) {
       if (ctx) await this.assertFileBelongsToCtx(matchedPath, ctx, sessionId);
       return matchedPath;
@@ -1047,7 +1493,7 @@ var PiSessionStore = class {
   }
   async linkedPiFileFor(filepath) {
     try {
-      const content = await readFile(filepath, "utf-8");
+      const content = await readFile3(filepath, "utf-8");
       return extractPiSessionFilePath(safeParseEntries(content));
     } catch {
       return null;
@@ -1067,35 +1513,51 @@ var PiSessionStore = class {
     return referenced;
   }
   async sessionSortKey({ filepath, stat }) {
-    let sortMtimeMs = stat.mtime.getTime();
-    let headerId = void 0;
+    let fileMtimeMs = Number(stat.mtimeMs);
+    let headerId;
     const stemFallback = () => ({
-      sortMtimeMs,
+      orderingUpdatedAtMs: fileMtimeMs,
       sortId: wrapperSessionId(filepath)
     });
     try {
       const cached = await this.readPrefixCache(filepath, stat);
+      fileMtimeMs = cached.mtimeMs;
       headerId = cached.headerId ?? void 0;
+      if (!headerId) return stemFallback();
       const linkedPiFile = cached.referencedPiFile;
-      if (linkedPiFile && resolve(linkedPiFile) !== resolve(filepath)) {
-        const linkedStat = await fsStat2(linkedPiFile);
-        sortMtimeMs = Math.max(sortMtimeMs, linkedStat.mtime.getTime());
-      }
-      if (!headerId) {
-        return stemFallback();
-      }
-      if (!isTimestampNamedPiSessionFile(filepath, headerId)) {
-        return { sortMtimeMs, sortId: headerId };
+      const hasLinkedTranscript = Boolean(
+        linkedPiFile && resolve(linkedPiFile) !== resolve(filepath)
+      );
+      const linkedStat = hasLinkedTranscript ? await fsStat2(linkedPiFile).catch(() => void 0) : void 0;
+      const linkedSnapshotMatches = linkedStat ? cached.linkedDev === Number(linkedStat.dev) && cached.linkedIno === Number(linkedStat.ino) && cached.linkedMtimeMs === Number(linkedStat.mtimeMs) && cached.linkedCtimeMs === Number(linkedStat.ctimeMs) && cached.linkedSize === Number(linkedStat.size) : cached.linkedMtimeMs === void 0 && cached.linkedSize === void 0;
+      if (cached.orderingUpdatedAtMs !== void 0 && (!hasLinkedTranscript || linkedSnapshotMatches)) {
+        return { orderingUpdatedAtMs: cached.orderingUpdatedAtMs, sortId: headerId };
       }
-      if (cached.nativeSortMtimeMs !== void 0) {
-        return { sortMtimeMs: cached.nativeSortMtimeMs, sortId: headerId };
+      let selectedOrdering;
+      if (linkedPiFile && linkedStat) {
+        const linkedOrdering = await nativeTranscriptOrdering(
+          linkedPiFile,
+          Number(linkedStat.size)
+        ).catch(() => void 0);
+        if (linkedOrdering?.hasEntries) selectedOrdering = linkedOrdering;
       }
-      const latest = await latestNativeMessageTimestamp(filepath, Number(stat.size));
-      if (latest === void 0) return { sortMtimeMs, sortId: headerId };
-      this.prefixCache.set(filepath, { ...cached, nativeSortMtimeMs: latest });
-      return { sortMtimeMs: latest, sortId: headerId };
+      selectedOrdering ??= await nativeTranscriptOrdering(filepath, cached.size).catch(() => ({ hasEntries: false }));
+      const orderingUpdatedAtMs = selectedOrdering.latestMessageAtMs ?? Math.max(fileMtimeMs, linkedStat ? Number(linkedStat.mtimeMs) : 0);
+      const { summary: _staleSummary, ...cacheWithoutSummary } = cached;
+      this.prefixCache.set(filepath, {
+        ...cacheWithoutSummary,
+        orderingUpdatedAtMs,
+        ...linkedStat ? {
+          linkedDev: Number(linkedStat.dev),
+          linkedIno: Number(linkedStat.ino),
+          linkedMtimeMs: Number(linkedStat.mtimeMs),
+          linkedCtimeMs: Number(linkedStat.ctimeMs),
+          linkedSize: Number(linkedStat.size)
+        } : {}
+      });
+      return { orderingUpdatedAtMs, sortId: headerId };
     } catch {
-      return headerId ? { sortMtimeMs, sortId: headerId } : stemFallback();
+      return headerId ? { orderingUpdatedAtMs: fileMtimeMs, sortId: headerId } : stemFallback();
     }
   }
   async summarizeFile(ctx, filepath, existingStat) {
@@ -1116,43 +1578,51 @@ var PiSessionStore = class {
       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"
-      );
       const linkedPiFile = extractPiSessionFilePath(entries);
-      const linked = linkedPiFile && resolve(linkedPiFile) !== resolve(filepath) ? await this.readLinkedPiSessionSummary(linkedPiFile) : null;
-      const linkedEntries = linked?.entries.filter(
-        (e) => e.type !== "session"
-      ) ?? [];
-      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 = nativeSummary?.latestMessageAtMs ?? Math.max(fileStat.mtime.getTime(), linked?.mtime.getTime() ?? 0);
+      const [sessionScan, linked, order] = await Promise.all([
+        this.readTranscriptSummary(filepath),
+        linkedPiFile && resolve(linkedPiFile) !== resolve(filepath) ? this.readLinkedPiSessionSummary(linkedPiFile) : null,
+        this.sessionSortKey({ filepath, stat: fileStat })
+      ]);
+      if (!sessionScan) return null;
+      const sessionTranscript = sessionScan.summary;
+      const transcript = selectTranscriptSummary(sessionTranscript, linked?.summary);
+      const title = projectedTranscriptTitle(sessionTranscript, linked?.summary) ?? "New session";
       const summary = {
         id: header.id,
         title,
         createdAt: header.timestamp,
-        updatedAt: new Date(updatedAtMs).toISOString(),
-        turnCount,
-        ...nativeSummary ? {
+        updatedAt: new Date(order.orderingUpdatedAtMs).toISOString(),
+        turnCount: transcript.turnCount,
+        ...directNative ? {
           nativeSessionId: header.id,
-          hasAssistantReply: nativeSummary.hasAssistantReply
+          hasAssistantReply: transcript.hasAssistantReply
         } : {}
       };
-      this.prefixCache.set(filepath, {
-        mtimeMs: fileStat.mtime.getTime(),
-        size: Number(fileStat.size),
-        referencedPiFile: linkedPiFile,
-        // Carried so a later `sessionSortMtimeMs` on this same entry still
-        // recognises a native transcript instead of falling back to mtime.
-        headerId: header.id,
-        ...cached?.nativeSortMtimeMs !== void 0 ? { nativeSortMtimeMs: cached.nativeSortMtimeMs } : {},
-        sessionCtx,
-        ...linked ? { linkedMtimeMs: linked.mtime.getTime(), linkedSize: linked.size } : {},
-        ...!nativeSummary ? { summary } : {}
-      });
+      const stableForCache = sessionScan.stable && sameFileSnapshot(fileStat, sessionScan.stat) && (!linked || linked.stable);
+      if (stableForCache) {
+        this.prefixCache.set(filepath, {
+          dev: Number(sessionScan.stat.dev),
+          ino: Number(sessionScan.stat.ino),
+          mtimeMs: Number(sessionScan.stat.mtimeMs),
+          ctimeMs: Number(sessionScan.stat.ctimeMs),
+          size: Number(sessionScan.stat.size),
+          referencedPiFile: linkedPiFile,
+          // Preserve the exact ordering timestamp emitted above while
+          // retaining snapshot identity required by title-authority caching.
+          headerId: header.id,
+          orderingUpdatedAtMs: order.orderingUpdatedAtMs,
+          sessionCtx,
+          ...linked ? {
+            linkedDev: Number(linked.dev),
+            linkedIno: Number(linked.ino),
+            linkedMtimeMs: linked.mtimeMs,
+            linkedCtimeMs: linked.ctimeMs,
+            linkedSize: linked.size
+          } : {},
+          summary
+        });
+      }
       return summary;
     } catch {
       return null;
@@ -1161,7 +1631,7 @@ var PiSessionStore = class {
   cachedPrefix(filepath, fileStat) {
     const cached = this.prefixCache.get(filepath);
     if (!cached) return void 0;
-    if (cached.mtimeMs !== fileStat.mtime.getTime() || cached.size !== Number(fileStat.size)) return void 0;
+    if (cached.dev !== Number(fileStat.dev) || cached.ino !== Number(fileStat.ino) || cached.mtimeMs !== Number(fileStat.mtimeMs) || cached.ctimeMs !== Number(fileStat.ctimeMs) || cached.size !== Number(fileStat.size)) return void 0;
     return cached;
   }
   async cachedSummaryIsFresh(filepath, cached) {
@@ -1169,7 +1639,7 @@ var PiSessionStore = class {
     if (!linkedPiFile || resolve(linkedPiFile) === resolve(filepath)) return true;
     try {
       const linkedStat = await fsStat2(linkedPiFile);
-      return cached.linkedMtimeMs === linkedStat.mtime.getTime() && cached.linkedSize === Number(linkedStat.size);
+      return cached.linkedDev === Number(linkedStat.dev) && cached.linkedIno === Number(linkedStat.ino) && cached.linkedMtimeMs === Number(linkedStat.mtimeMs) && cached.linkedCtimeMs === Number(linkedStat.ctimeMs) && cached.linkedSize === Number(linkedStat.size);
     } catch {
       return cached.linkedMtimeMs === void 0 && cached.linkedSize === void 0;
     }
@@ -1177,17 +1647,29 @@ var PiSessionStore = class {
   async readPrefixCache(filepath, fileStat) {
     const cached = this.cachedPrefix(filepath, fileStat);
     if (cached) return cached;
-    const content = await readJsonlPrefix2(filepath);
-    const entries = parseJsonlPrefixEntries2(content);
-    const header = entries.find((item) => item.type === "session");
-    const entry = {
-      mtimeMs: fileStat.mtime.getTime(),
-      size: Number(fileStat.size),
-      referencedPiFile: extractPiSessionFilePath(entries),
-      headerId: header?.id ?? null,
-      sessionCtx: readHeaderSessionCtx(header)
-    };
-    this.prefixCache.set(filepath, entry);
+    let before = fileStat;
+    let entry;
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+      const content = await readJsonlPrefix2(filepath);
+      const after = await fsStat2(filepath);
+      const entries = parseJsonlPrefixEntries2(content);
+      const header = entries.find((item) => item.type === "session");
+      entry = {
+        dev: Number(after.dev),
+        ino: Number(after.ino),
+        mtimeMs: Number(after.mtimeMs),
+        ctimeMs: Number(after.ctimeMs),
+        size: Number(after.size),
+        referencedPiFile: extractPiSessionFilePath(entries),
+        headerId: header?.id ?? null,
+        sessionCtx: readHeaderSessionCtx(header)
+      };
+      if (sameFileSnapshot(before, after)) {
+        this.prefixCache.set(filepath, entry);
+        return entry;
+      }
+      before = after;
+    }
     return entry;
   }
   async summarizeVisiblePage(visibleFiles, options) {
@@ -1195,15 +1677,19 @@ var PiSessionStore = class {
     const page = [];
     let validSeen = 0;
     let index = 0;
-    const batchSize = options.limit === void 0 ? Math.max(1, visibleFiles.length) : Math.max(1, options.limit);
+    const batchSize = Math.min(
+      MAX_CONCURRENT_SESSION_SUMMARIES,
+      options.limit === void 0 ? Math.max(1, visibleFiles.length) : Math.max(1, options.limit)
+    );
     while (index < visibleFiles.length && (options.limit === void 0 || page.length < options.limit)) {
       const batch = visibleFiles.slice(index, index + batchSize);
       index += batch.length;
       const summaries = await Promise.all(
         batch.map(({ filepath, stat }) => this.summarizeFile(options.ctx, filepath, stat))
       );
-      for (const summary of summaries) {
-        if (!summary) continue;
+      for (const rawSummary of summaries) {
+        if (!rawSummary) continue;
+        const summary = withArchivedFlag(rawSummary, options.archivedIds);
         if (summary.turnCount === 0 && !options.includeEmpty && summary.id !== options.includeId) {
           continue;
         }
@@ -1232,7 +1718,7 @@ var PiSessionStore = class {
     try {
       const files = readdirSync(this.sessionDir).filter((file) => file.endsWith(".jsonl"));
       for (const file of files) {
-        const filepath = join(this.sessionDir, file);
+        const filepath = join2(this.sessionDir, file);
         if (resolve(filepath) === resolvedNativePath) continue;
         try {
           const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries2(readJsonlPrefixSync(filepath)));
@@ -1247,10 +1733,10 @@ var PiSessionStore = class {
   }
   async findWrapperReferencingNativeSession(nativePath) {
     const resolvedNativePath = resolve(nativePath);
-    const files = await readdir(this.sessionDir).catch(() => []);
+    const files = await readdir2(this.sessionDir).catch(() => []);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) continue;
-      const filepath = join(this.sessionDir, file);
+      const filepath = join2(this.sessionDir, file);
       if (resolve(filepath) === resolvedNativePath) continue;
       try {
         const linkedPiFile = extractPiSessionFilePath(parseJsonlPrefixEntries2(await readJsonlPrefix2(filepath)));
@@ -1261,7 +1747,7 @@ var PiSessionStore = class {
     return null;
   }
   ensureWrapperForNativeSessionSync(sessionId, nativePath, entries, ctx) {
-    const wrapperPath = join(this.sessionDir, `${sessionId}.jsonl`);
+    const wrapperPath = join2(this.sessionDir, `${sessionId}.jsonl`);
     if (resolve(wrapperPath) === resolve(nativePath)) return wrapperPath;
     try {
       readFileSync(wrapperPath, "utf-8");
@@ -1281,7 +1767,7 @@ var PiSessionStore = class {
     return wrapperPath;
   }
   async ensureWrapperForNativeSession(sessionId, nativePath, ctx) {
-    const wrapperPath = join(this.sessionDir, `${sessionId}.jsonl`);
+    const wrapperPath = join2(this.sessionDir, `${sessionId}.jsonl`);
     if (resolve(wrapperPath) === resolve(nativePath)) return wrapperPath;
     try {
       await fsStat2(wrapperPath);
@@ -1290,7 +1776,7 @@ var PiSessionStore = class {
     }
     const entries = parseJsonlPrefixEntries2(await readJsonlPrefix2(nativePath));
     try {
-      await writeFile(
+      await writeFile2(
         wrapperPath,
         buildNativePiSessionWrapper(sessionId, this.cwd, nativePath, entries, ctx),
         { encoding: "utf-8", flag: "wx" }
@@ -1302,27 +1788,67 @@ var PiSessionStore = class {
     return wrapperPath;
   }
   async readLinkedPiSession(filepath) {
+    let last;
+    let parsed;
     try {
-      const [fileStat, content] = await Promise.all([
-        fsStat2(filepath),
-        readFile(filepath, "utf-8")
-      ]);
-      return { entries: safeParseEntries(content), mtime: fileStat.mtime, size: Number(fileStat.size) };
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        const before = await fsStat2(filepath);
+        parsed = parseSessionTranscript(await readFile3(filepath, "utf-8"));
+        const after = await fsStat2(filepath);
+        last = after;
+        if (sameFileSnapshot(before, after)) {
+          return {
+            ...parsed,
+            dev: Number(after.dev),
+            ino: Number(after.ino),
+            mtimeMs: Number(after.mtimeMs),
+            ctimeMs: Number(after.ctimeMs),
+            size: Number(after.size),
+            stable: true
+          };
+        }
+      }
+      return parsed && last ? {
+        ...parsed,
+        dev: Number(last.dev),
+        ino: Number(last.ino),
+        mtimeMs: Number(last.mtimeMs),
+        ctimeMs: Number(last.ctimeMs),
+        size: Number(last.size),
+        stable: false
+      } : null;
     } catch {
       return null;
     }
   }
-  async readLinkedPiSessionSummary(filepath) {
+  async readTranscriptSummary(filepath) {
+    let last;
+    let summary;
     try {
-      const [fileStat, content] = await Promise.all([
-        fsStat2(filepath),
-        readJsonlPrefix2(filepath)
-      ]);
-      return { entries: parseJsonlPrefixEntries2(content), mtime: fileStat.mtime, size: Number(fileStat.size) };
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        const before = await fsStat2(filepath);
+        summary = await summarizeSessionTranscript(filepath);
+        const after = await fsStat2(filepath);
+        last = after;
+        if (sameFileSnapshot(before, after)) return { summary, stat: after, stable: true };
+      }
+      return summary && last ? { summary, stat: last, stable: false } : null;
     } catch {
       return null;
     }
   }
+  async readLinkedPiSessionSummary(filepath) {
+    const scan = await this.readTranscriptSummary(filepath);
+    return scan ? {
+      summary: scan.summary,
+      dev: Number(scan.stat.dev),
+      ino: Number(scan.stat.ino),
+      mtimeMs: Number(scan.stat.mtimeMs),
+      ctimeMs: Number(scan.stat.ctimeMs),
+      size: Number(scan.stat.size),
+      stable: scan.stable
+    } : null;
+  }
   headerBelongsToCtx(header, ctx, directNative = false) {
     if (directNative) return this.nativeFileBelongsToCtx(header, ctx);
     return header ? this.storedCtxBelongsToCtx(readHeaderSessionCtx(header), ctx) : isEmptySessionCtx(ctx);
@@ -1362,7 +1888,7 @@ var PiSessionStore = class {
   }
 };
 async function readJsonlPrefix2(filepath, maxBytes = SUMMARY_PREFIX_BYTES2) {
-  const handle = await open4(filepath, "r");
+  const handle = await open3(filepath, "r");
   try {
     const buffer = Buffer.alloc(maxBytes);
     const { bytesRead } = await handle.read(buffer, 0, maxBytes, 0);
@@ -1458,35 +1984,15 @@ function isTimestampNamedPiSessionFile(filepath, sessionId) {
   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 sameFileSnapshot(first, second) {
+  return first.dev === second.dev && first.ino === second.ino && first.size === second.size && first.mtimeMs === second.mtimeMs && first.ctimeMs === second.ctimeMs;
 }
-function hasAssistantReply(entries) {
-  return entries.some(
-    (entry) => entry.type === "message" && entry.message.role === "assistant"
-  );
+function selectTranscriptSummary(wrapper, native) {
+  return native && native.entryCount > 0 ? native : wrapper;
 }
-function newestDurableTitle(wrapperEntries, nativeEntries) {
-  const candidates = [
-    ...wrapperEntries.flatMap((entry, offset) => entry.type === "session_info" ? [{ entry, native: 0, offset }] : []),
-    ...nativeEntries.flatMap((entry, offset) => entry.type === "session_info" ? [{ entry, native: 1, offset }] : [])
-  ];
-  candidates.sort((a, b) => {
-    const timestamp = Date.parse(b.entry.timestamp) - Date.parse(a.entry.timestamp);
-    return timestamp || b.native - a.native || b.offset - a.offset;
-  });
-  return candidates[0]?.entry.name;
-}
-function firstUserMessage(entries) {
-  for (const e of entries) {
-    if (e.type !== "message") continue;
-    const msg = e.message;
-    if (msg?.role !== "user") continue;
-    const text = textFromPiContent2(msg.content);
-    if (text) return text.slice(0, 80);
-  }
+function projectedTranscriptTitle(wrapper, native) {
+  const selected = selectTranscriptSummary(wrapper, native);
+  return wrapper.userTitle ?? selected.title ?? wrapper.title ?? native?.title ?? selected.firstUserTitle;
 }
 function safeParseEntries(content) {
   try {
@@ -1514,14 +2020,6 @@ function parseJsonlPrefixEntries2(content) {
   }
   return entries;
 }
-function textFromPiContent2(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("");
-}
 function withStableMessageId(message, entryId) {
   if (!entryId || !message || typeof message !== "object" || Array.isArray(message)) return message;
   if (typeof message.id === "string") return message;
@@ -1622,7 +2120,7 @@ function readApiKeyEnv(candidates) {
 function buildOpenAICompatibleProviderConfig(opts) {
   return {
     baseUrl: opts.baseUrl,
-    // pi-coding-agent 0.80.7 resolves `$ENV_VAR` config references through
+    // Pi resolves `$ENV_VAR` config references through
     // the provider environment. A bare name is a literal API key, which would
     // send "INFOMANIAK_API_TOKEN" as the bearer token and cause provider 401s.
     apiKey: `$${opts.apiKeyEnv}`,
@@ -1753,6 +2251,17 @@ function readConfiguredDefaultModel() {
   return readPiSettingsDefaultModel() ?? readInfomaniakProvider()?.defaultModel ?? readCustomProvider()?.defaultModel;
 }
 
+// src/server/models/modelRuntime.ts
+import {
+  ModelRuntime
+} from "@mariozechner/pi-coding-agent";
+async function createConfiguredModelRuntime(options) {
+  const modelRuntime = await ModelRuntime.create(options);
+  const configuredModels = registerConfiguredModelProviders(modelRuntime);
+  await modelRuntime.refresh({ allowNetwork: false });
+  return { modelRuntime, configuredModels };
+}
+
 // src/server/piPackages.ts
 var PI_PACKAGE_RESOURCE_FILTERS = [
   "extensions",
@@ -1797,7 +2306,7 @@ function mergePiPackageSources(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 { join as join3 } from "node:path";
 import { SettingsManager as SettingsManager2 } from "@mariozechner/pi-coding-agent";
 function readSettingsFileIfPresent(path) {
   return existsSync(path) ? readFileSync2(path, "utf-8") : void 0;
@@ -1812,8 +2321,8 @@ function mergeInjectedProjectPackages(settingsJson, piPackages, includePackage)
 }
 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");
+  const globalSettingsPath = join3(agentDir, "settings.json");
+  const projectSettingsPath = join3(cwd, ".pi", "settings.json");
   let globalSettingsOverrideJson;
   let projectSettingsOverrideJson;
   const storage = {
@@ -1931,11 +2440,11 @@ function meteredExtensionCommandContext(ctx, command) {
   guarded.switchSession = async () => block();
   return guarded;
 }
-function resolveRequestedModel(modelRegistry, input, options = {}) {
+function resolveRequestedModel(modelRuntime, input, options = {}) {
   const requestedId = input.model?.id;
   if (!input.model || !requestedId) return void 0;
-  const model = modelRegistry.find(input.model.provider, requestedId);
-  const available = modelRegistry.getAvailable();
+  const model = modelRuntime.getModel(input.model.provider, requestedId);
+  const available = modelRuntime.getAvailableSnapshot();
   const hasAuth = Boolean(model) && available.some(
     (m) => m.provider === model.provider && m.id === model.id
   );
@@ -1945,13 +2454,13 @@ function resolveRequestedModel(modelRegistry, input, options = {}) {
   }
   return model;
 }
-function resolveDefaultModel(modelRegistry, override, strict) {
+function resolveDefaultModel(modelRuntime, override, strict) {
   if (override) {
-    return resolveRequestedModel(modelRegistry, { model: override }, { strict });
+    return resolveRequestedModel(modelRuntime, { model: override }, { strict });
   }
   const configured = readConfiguredDefaultModel();
   if (configured) {
-    const model = modelRegistry.find(configured.provider, configured.id);
+    const model = modelRuntime.getModel(configured.provider, configured.id);
     if (model) return model;
   }
   return void 0;
@@ -1970,7 +2479,7 @@ function sessionCacheKey(sessionId, ctx) {
   return JSON.stringify([sessionId, ctx.workspaceId ?? ""]);
 }
 async function applyRequestedSessionOptions(handle, input, options = {}) {
-  const requestedModel = resolveRequestedModel(handle.modelRegistry, input, { strict: options.strictModelResolution });
+  const requestedModel = resolveRequestedModel(handle.modelRuntime, input, { strict: options.strictModelResolution });
   if (requestedModel) {
     const current = handle.piSession.model;
     if (!current || current.provider !== requestedModel.provider || current.id !== requestedModel.id) {
@@ -2102,10 +2611,7 @@ function createPiCodingAgentHarness(opts) {
     return await runContextStorage.run(ctx, run);
   }
   function createRunBoundAdapter(handle, sessionId, ctx) {
-    const adapter = createPiAgentSessionAdapter(handle.piSession, {
-      sessionId,
-      ...handle.piSession.agent && typeof handle.piSession.agent.continue === "function" ? { continueQueuedFollowUp: () => handle.piSession.agent.continue() } : {}
-    });
+    const adapter = createPiAgentSessionAdapter(handle.piSession, { sessionId });
     return {
       ...adapter,
       prompt: (promptInput) => bindRunContext(ctx, () => adapter.prompt(promptInput)),
@@ -2115,11 +2621,9 @@ function createPiCodingAgentHarness(opts) {
     };
   }
   async function createPiSession(sessionId, sessionCtx, input, ctx) {
-    const authStorage = AuthStorage.create();
-    const modelRegistry = ModelRegistry.create(authStorage);
-    registerConfiguredModelProviders(modelRegistry);
-    const resolvedModel = resolveRequestedModel(modelRegistry, input, { strict: pi.strictModelResolution });
-    const model = resolvedModel ?? resolveDefaultModel(modelRegistry, pi.defaultModel, pi.strictModelResolution);
+    const { modelRuntime } = await createConfiguredModelRuntime();
+    const resolvedModel = resolveRequestedModel(modelRuntime, input, { strict: pi.strictModelResolution });
+    const model = resolvedModel ?? resolveDefaultModel(modelRuntime, pi.defaultModel, pi.strictModelResolution);
     const savedPiFile = await sessionStore.loadPiSessionFile(sessionCtx, sessionId);
     const runtimeCwd = opts.runtimeCwd ?? ctx.workdir;
     if (!savedPiFile) {
@@ -2193,8 +2697,8 @@ function createPiCodingAgentHarness(opts) {
       model,
       thinkingLevel: input.thinkingLevel ?? "off",
       sessionManager,
-      authStorage,
-      modelRegistry,
+      modelRuntime,
+      settingsManager,
       ...resourceLoader ? { resourceLoader } : {}
     });
     const restoreFollowUpContextWrapper = rememberQueuedFollowUpRunContexts(piSession, runContextState, () => runContextStorage.getStore());
@@ -2205,7 +2709,7 @@ function createPiCodingAgentHarness(opts) {
     };
     const handle = {
       piSession,
-      modelRegistry,
+      modelRuntime,
       sessionManager,
       resourceLoader,
       sessionId,
@@ -2267,7 +2771,8 @@ function createPiCodingAgentHarness(opts) {
      * the expected pre-first-turn state, not an error.
      */
     getSystemPrompt(sessionId) {
-      return piSessionHandlesFor(sessionId)[0]?.piSession.systemPrompt;
+      const prompt = piSessionHandlesFor(sessionId)[0]?.piSession.systemPrompt;
+      return prompt && pi.locateSkillResource ? projectSkillResourceLocations(prompt, pi.locateSkillResource) : prompt;
     },
     hasPiSession(sessionId, ctx) {
       return ctx ? piSessions.has(sessionCacheKey(sessionId, ctx)) : piSessionHandlesFor(sessionId).length > 0;
@@ -2339,8 +2844,8 @@ export {
   getEnv,
   PiSessionStore,
   parseEncodedModelSelection,
-  registerConfiguredModelProviders,
   readConfiguredDefaultModel,
+  createConfiguredModelRuntime,
   PI_PACKAGE_RESOURCE_FILTERS,
   piPackageSourceKey,
   compactPiPackages,