@mrrlin-dev/mcp 0.4.10 → 0.4.15

package/dist/bin.cjs

@@ -8166,7 +8166,7 @@ var require_graceful_fs = __commonJS({
     function patch(fs11) {
       polyfills(fs11);
       fs11.gracefulify = patch;
-      fs11.createReadStream = createReadStream;
+      fs11.createReadStream = createReadStream2;
       fs11.createWriteStream = createWriteStream;
       var fs$readFile = fs11.readFile;
       fs11.readFile = readFile9;
@@ -8376,7 +8376,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path22, options) {
+      function createReadStream2(path22, options) {
         return new fs11.ReadStream(path22, options);
       }
       function createWriteStream(path22, options) {
@@ -20644,11 +20644,11 @@ var require_dist = __commonJS({
 });
 
 // src/bin.ts
-var import_node_path30 = __toESM(require("node:path"), 1);
+var import_node_path31 = __toESM(require("node:path"), 1);
 var import_node_child_process18 = require("node:child_process");
-var import_node_fs17 = require("node:fs");
+var import_node_fs18 = require("node:fs");
 var import_node_os15 = require("node:os");
-var import_node_path31 = __toESM(require("node:path"), 1);
+var import_node_path32 = __toESM(require("node:path"), 1);
 
 // src/install-codex.ts
 var import_promises = __toESM(require("node:fs/promises"), 1);
@@ -21471,10 +21471,10 @@ async function verifyProviderReadiness(provider, run3, opts = {}) {
 }
 
 // src/director-bridge.ts
-var import_node_fs16 = __toESM(require("node:fs"), 1);
+var import_node_fs17 = __toESM(require("node:fs"), 1);
 var import_node_http = __toESM(require("node:http"), 1);
 var import_node_os11 = __toESM(require("node:os"), 1);
-var import_node_path23 = __toESM(require("node:path"), 1);
+var import_node_path24 = __toESM(require("node:path"), 1);
 var import_node_child_process15 = require("node:child_process");
 var import_node_crypto9 = __toESM(require("node:crypto"), 1);
 
@@ -36828,6 +36828,8 @@ var openApiOperationIds = {
   getArtifactFile: "getArtifactFile",
   downloadArtifactFile: "downloadArtifactFile",
   listArtifactFiles: "listArtifactFiles",
+  listArtifactFileExcerpts: "listArtifactFileExcerpts",
+  getArtifactFileContent: "getArtifactFileContent",
   getOperatorSettings: "getOperatorSettings",
   updateOperatorSettings: "updateOperatorSettings",
   recordOperatorPresence: "recordOperatorPresence",
@@ -36842,7 +36844,8 @@ var openApiOperationIds = {
   recordSpecConsensusReview: "recordSpecConsensusReview",
   getSpecConsensusReview: "getSpecConsensusReview",
   onboardingKickoffTransition: "onboardingKickoffTransition",
-  ingestTelemetry: "ingestTelemetry"
+  ingestTelemetry: "ingestTelemetry",
+  getTelemetry: "getTelemetry"
 };
 
 // ../../packages/schemas/dist/session.js
@@ -37284,6 +37287,20 @@ function totalSize(items) {
   return items.reduce((sum, i) => sum + i.size, 0);
 }
 
+// ../../packages/schemas/dist/inboxProposal.js
+function isRunnableProposal(item) {
+  if (item.kind !== "proposal") {
+    return false;
+  }
+  if (item.actionPayload === null || item.actionPayload === void 0) {
+    return false;
+  }
+  if (item.taskId === null || item.taskId === void 0 || item.taskId === "") {
+    return false;
+  }
+  return true;
+}
+
 // ../../packages/schemas/dist/index.js
 var mrrlinTaskStatusSchema = external_exports.enum([
   "backlog",
@@ -38460,6 +38477,13 @@ var artifactFileCreateResponseSchema = external_exports.object({
   })
 });
 var artifactFileListResponseSchema = external_exports.object({ data: external_exports.array(mrrlinArtifactFilePublicSchema) });
+var mrrlinArtifactFileExcerptSchema = external_exports.object({
+  excerpt: external_exports.string(),
+  id: external_exports.string().uuid()
+});
+var mrrlinArtifactFileExcerptsResponseSchema = external_exports.object({
+  data: external_exports.array(mrrlinArtifactFileExcerptSchema)
+});
 var artifactFileExpiredResponseSchema = external_exports.object({
   artifact: external_exports.object({
     class: mrrlinArtifactFileClassSchema,
@@ -40175,6 +40199,46 @@ function createMrrlinClient(config2) {
     }
     return response.json();
   }
+  async function requestText(path22, init) {
+    const method = init?.method ?? "GET";
+    const headers = new Headers(init?.headers ?? {});
+    if (token && !headers.has("authorization")) {
+      headers.set("authorization", `Bearer ${token}`);
+    }
+    const response = await customFetch(`${baseUrl}${path22}`, { ...init, headers });
+    if (!response.ok) {
+      const body = await response.text();
+      let code = `HTTP_${response.status}`;
+      let violations = null;
+      let message = `Mrrlin API ${method} ${path22} failed: ${response.status}`;
+      try {
+        const parsed = JSON.parse(body);
+        const violationsParsed = apiViolationsErrorSchema.safeParse(parsed);
+        if (violationsParsed.success) {
+          code = violationsParsed.data.code;
+          violations = violationsParsed.data.violations;
+          message = violationsParsed.data.message;
+        } else {
+          const errorParsed = apiErrorSchema.safeParse(parsed);
+          if (errorParsed.success) {
+            code = errorParsed.data.code;
+            message = errorParsed.data.message;
+          }
+        }
+      } catch {
+      }
+      throw new MrrlinApiError({
+        code,
+        method,
+        path: path22,
+        responseBody: body,
+        status: response.status,
+        violations,
+        message
+      });
+    }
+    return response.text();
+  }
   return {
     async listGithubInstallations() {
       const body = await request(`/github/installations`);
@@ -40894,6 +40958,14 @@ function createMrrlinClient(config2) {
       const body = await request(`${projectPath(projectSlug)}/artifact-files${suffix}`);
       return artifactFileListResponseSchema.parse(body).data;
     },
+    async listArtifactFileExcerpts(projectSlug, taskId) {
+      const params = new URLSearchParams({ taskId });
+      const body = await request(`${projectPath(projectSlug)}/artifact-file-excerpts?${params.toString()}`);
+      return mrrlinArtifactFileExcerptsResponseSchema.parse(body).data;
+    },
+    async getArtifactFileContent(projectSlug, artifactFileId) {
+      return requestText(`${projectPath(projectSlug)}/artifact-files/${encodeURIComponent(artifactFileId)}/content`);
+    },
     async getProjectSchedulerPolicy(projectSlug) {
       const body = await request(`${projectPath(projectSlug)}/scheduler/policy`);
       return projectSchedulerPolicyResponseSchema.parse(body).data;
@@ -41292,16 +41364,16 @@ function resolveBinPath(opts) {
       return null;
     }
   });
-  const existsSync4 = opts.existsSync ?? import_node_fs2.existsSync;
+  const existsSync5 = opts.existsSync ?? import_node_fs2.existsSync;
   const resolved = whichSync(BIN_NAME);
-  if (resolved && existsSync4(resolved)) {
+  if (resolved && existsSync5(resolved)) {
     return { path: resolved, source: "which" };
   }
   const envPath = (opts.env ?? process.env).PATH ?? "";
   for (const dir of envPath.split(import_node_path5.default.delimiter)) {
     if (!dir) continue;
     const candidate = import_node_path5.default.join(dir, BIN_NAME);
-    if (existsSync4(candidate)) {
+    if (existsSync5(candidate)) {
       return { path: candidate, source: "path-walk" };
     }
   }
@@ -41551,7 +41623,7 @@ Do NOT derail the current task - if the operator has an in-flight question, answ
 }
 
 // src/_generated/version.ts
-var PKG_VERSION = "0.4.10";
+var PKG_VERSION = "0.4.15";
 
 // src/api-base-url-migrate.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
@@ -42114,6 +42186,9 @@ function startSchedulerTickLoop(deps) {
 // src/retention/pruner.ts
 var import_promises4 = require("node:fs/promises");
 var import_node_path9 = __toESM(require("node:path"), 1);
+function protectedDayFloor(protectedSinceMs) {
+  return new Date(protectedSinceMs).toISOString().slice(0, 10);
+}
 async function prune(stateDir, bounds) {
   const logsDir = import_node_path9.default.join(stateDir, "logs");
   let entries;
@@ -42122,7 +42197,7 @@ async function prune(stateDir, bounds) {
   } catch (err) {
     if (err?.code === "ENOENT") {
       await emitPruneLog(stateDir, [], {}, 0, null);
-      return { daysRemoved: [], reasonByDay: {}, bytesRemoved: 0, oldestDayRemaining: null };
+      return { daysRemoved: [], reasonByDay: {}, bytesRemoved: 0, oldestDayRemaining: null, budgetOvershootBytes: 0 };
     }
     throw err;
   }
@@ -42166,12 +42241,15 @@ async function prune(stateDir, bounds) {
     }
     return true;
   }
+  const protectedFromDay = bounds.protectedSinceMs === void 0 ? null : protectedDayFloor(bounds.protectedSinceMs);
+  const isProtected = (day) => protectedFromDay !== null && day >= protectedFromDay;
   const budgetBytes = bounds.budgetMb * 1024 * 1024;
   let totalSize2 = files.reduce((sum, f) => sum + f.size, 0);
   let i = 0;
   while (totalSize2 > budgetBytes && i < files.length) {
     const candidate = files[i];
     if (!candidate) break;
+    if (isProtected(candidate.day)) break;
     if (!await isDaySafeToDelete(candidate.day)) {
       i += 1;
       continue;
@@ -42189,16 +42267,18 @@ async function prune(stateDir, bounds) {
   for (const info of files) {
     const fileDate = /* @__PURE__ */ new Date(`${info.day}T00:00:00Z`);
     const ageInDays = (now - fileDate.getTime()) / msPerDay;
-    if (ageInDays > bounds.ageDays && await isDaySafeToDelete(info.day)) {
+    if (ageInDays > bounds.ageDays && !isProtected(info.day) && await isDaySafeToDelete(info.day)) {
       await (0, import_promises4.unlink)(info.fullPath);
       daysRemoved.push(info.day);
       reasonByDay[info.day] = "age";
       bytesRemoved += info.size;
+      totalSize2 -= info.size;
       continue;
     }
     stillRemaining.push(info);
   }
   const oldestDayRemaining = stillRemaining.length > 0 ? stillRemaining[0]?.day ?? null : null;
+  const budgetOvershootBytes = Math.max(0, totalSize2 - budgetBytes);
   await emitPruneLog(stateDir, daysRemoved, reasonByDay, bytesRemoved, oldestDayRemaining);
   if (daysRemoved.length > 0) {
     const sessionsPath = import_node_path9.default.join(logsDir, ".sessions.json");
@@ -42220,7 +42300,7 @@ async function prune(stateDir, bounds) {
       await (0, import_promises4.rename)(tmpPath, sessionsPath);
     }
   }
-  return { daysRemoved, reasonByDay, bytesRemoved, oldestDayRemaining };
+  return { daysRemoved, reasonByDay, bytesRemoved, oldestDayRemaining, budgetOvershootBytes };
 }
 async function emitPruneLog(stateDir, daysRemoved, reasonByDay, bytesRemoved, oldestDayRemaining) {
   const logsDir = import_node_path9.default.join(stateDir, "logs");
@@ -44029,50 +44109,102 @@ async function uploadPendingDays(stateDir, client, bridgeHealth, gateCtx) {
   const fullUnprocessed = pending.map((p) => ({ projectSlug: p.projectSlug, day: p.day }));
   pending.sort((a, b) => a.day.localeCompare(b.day));
   for (const cur of pending) {
-    let raw;
+    const failurePath = (0, import_node_path12.join)(telemetryDir, `.failed-${cur.projectSlug}-${cur.day}.json`);
+    let failureState = null;
     try {
-      raw = await (0, import_promises6.readFile)(cur.rowsPath, "utf8");
-    } catch (err) {
-      console.error(`uploadPendingDays: failed to read ${cur.rowsPath}`, err);
-      continue;
-    }
-    const rows = [];
-    for (const line of raw.split("\n")) {
-      if (!line.trim()) continue;
-      try {
-        rows.push({ ...JSON.parse(line), gateMarker: "gated" });
-      } catch {
-      }
+      const data = await (0, import_promises6.readFile)(failurePath, "utf8");
+      failureState = JSON.parse(data);
+    } catch {
+      failureState = null;
     }
-    const batch = {
-      day: cur.day,
-      bridgeVersion: PKG_VERSION,
-      knownCrashCount,
-      unprocessedPartitions: fullUnprocessed.filter(
-        (p) => !(p.projectSlug === cur.projectSlug && p.day === cur.day)
-      ),
-      rows
-    };
-    const gateResult = await gate(batch, [], gateCtx);
-    const gateMarker = gateResult.gated ? "gated" : "projection-only";
-    for (const row of gateResult.artifact.rows) row.gateMarker = gateMarker;
-    const targetProject = cur.projectSlug === "_unattributed" ? process.env.MRRLIN_TELEMETRY_DEFAULT_PROJECT : cur.projectSlug;
-    if (!targetProject) {
-      console.error(`uploadPendingDays: no target project resolved for _unattributed/${cur.day}`);
+    const now = Date.now();
+    if (failureState && failureState.nextAttemptAt > now) {
       continue;
     }
+    let success2 = false;
     try {
+      let raw;
+      try {
+        raw = await (0, import_promises6.readFile)(cur.rowsPath, "utf8");
+      } catch (err) {
+        console.error(`uploadPendingDays: failed to read ${cur.rowsPath}`, err);
+        throw err;
+      }
+      const rows = [];
+      for (const line of raw.split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          rows.push({ ...JSON.parse(line), gateMarker: "gated" });
+        } catch {
+        }
+      }
+      const batch = {
+        day: cur.day,
+        bridgeVersion: PKG_VERSION,
+        knownCrashCount,
+        unprocessedPartitions: fullUnprocessed.filter(
+          (p) => !(p.projectSlug === cur.projectSlug && p.day === cur.day)
+        ),
+        rows
+      };
+      const gateResult = await gate(batch, [], gateCtx);
+      const gateMarker = gateResult.gated ? "gated" : "projection-only";
+      for (const row of gateResult.artifact.rows) row.gateMarker = gateMarker;
+      const targetProject = cur.projectSlug === "_unattributed" ? process.env.MRRLIN_TELEMETRY_DEFAULT_PROJECT : cur.projectSlug;
+      if (!targetProject) {
+        console.error(`uploadPendingDays: no target project resolved for _unattributed/${cur.day}`);
+        continue;
+      }
       await client.postTelemetry(targetProject, gateResult.artifact);
-    } catch (err) {
-      console.error(`uploadPendingDays: postTelemetry failed for ${cur.projectSlug}/${cur.day}`, err);
-      continue;
+      success2 = true;
+    } catch {
+      success2 = false;
     }
-    const tmpMarker = `${cur.markerPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
-    try {
-      await (0, import_promises6.writeFile)(tmpMarker, "");
-      await (0, import_promises6.rename)(tmpMarker, cur.markerPath);
-    } catch (err) {
-      console.error(`uploadPendingDays: failed to write marker for ${cur.projectSlug}/${cur.day}`, err);
+    if (success2) {
+      const tmpMarker = `${cur.markerPath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+      try {
+        await (0, import_promises6.writeFile)(tmpMarker, "");
+        await (0, import_promises6.rename)(tmpMarker, cur.markerPath);
+      } catch (err) {
+        console.error(`uploadPendingDays: failed to write marker for ${cur.projectSlug}/${cur.day}`, err);
+      }
+      if (failureState) {
+        try {
+          await (0, import_promises6.unlink)(failurePath);
+          console.log(`uploadPendingDays: partition ${cur.projectSlug}/${cur.day} recovered after ${failureState.failureCount + 1} consecutive failures`);
+        } catch (err) {
+          console.error(`uploadPendingDays: failed to remove failure state for ${cur.projectSlug}/${cur.day}`, err);
+        }
+      }
+    } else {
+      let newFailureCount = 1;
+      if (failureState) {
+        newFailureCount = failureState.failureCount + 1;
+      }
+      const baseDelayMs = 36e5;
+      const maxDelayMs = 864e5;
+      let delayMs2 = 0;
+      if (newFailureCount >= 2) {
+        delayMs2 = baseDelayMs * 2 ** (newFailureCount - 2);
+        if (delayMs2 > maxDelayMs) {
+          delayMs2 = maxDelayMs;
+        }
+      }
+      const nextAttemptAt = now + delayMs2;
+      const newFailureState = {
+        failureCount: newFailureCount,
+        nextAttemptAt
+      };
+      const tmpFailurePath = `${failurePath}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+      try {
+        await (0, import_promises6.writeFile)(tmpFailurePath, JSON.stringify(newFailureState));
+        await (0, import_promises6.rename)(tmpFailurePath, failurePath);
+      } catch (writeErr) {
+        console.error(`uploadPendingDays: failed to write failure state for ${cur.projectSlug}/${cur.day}`, writeErr);
+      }
+      if (!failureState) {
+        console.error(`uploadPendingDays: partition ${cur.projectSlug}/${cur.day} entering backoff after first failure`);
+      }
     }
   }
 }
@@ -47878,7 +48010,7 @@ function resolveBridgeLogEnabled(env = process.env) {
   const raw = (env.MRRLIN_DIRECTOR_BRIDGE_LOG ?? "").trim().toLowerCase();
   return !(raw === "0" || raw === "false");
 }
-function resolvePromptsEnabled(env) {
+function resolvePromptsEnabled(env = process.env) {
   const raw = (env.MRRLIN_DIRECTOR_BRIDGE_LOG_PROMPTS ?? "").trim().toLowerCase();
   return !(raw === "0" || raw === "false");
 }
@@ -52292,7 +52424,8 @@ function boundInboxItems(items) {
       kind: it.kind,
       status: it.status,
       body,
-      ...it.taskId ? { taskId: it.taskId } : {}
+      ...it.taskId ? { taskId: it.taskId } : {},
+      ...it.kind === "proposal" ? { runnable: isRunnableProposal(it) } : {}
     };
     const size = enc2.encode(JSON.stringify(projected)).length + 1;
     if (bytes3 + size > MAX_INBOX_PAYLOAD_BYTES && out.length > 0) break;
@@ -52780,19 +52913,179 @@ function extractVerificationSection(markdown) {
   return body.length > 0 ? body : null;
 }
 
+// src/director-reseed.ts
+var import_node_fs15 = require("node:fs");
+var import_node_readline = require("node:readline");
+var import_node_path22 = require("node:path");
+function estimateTokens(s) {
+  return Buffer.byteLength(s, "utf8");
+}
+function dayFilesInWindow(now, windowMs) {
+  const end = new Date(now.getTime());
+  const start = new Date(now.getTime() - windowMs);
+  const startDay = new Date(Date.UTC(
+    start.getUTCFullYear(),
+    start.getUTCMonth(),
+    start.getUTCDate(),
+    0,
+    0,
+    0,
+    0
+  ));
+  const files = [];
+  for (let cur = new Date(startDay); cur.getTime() <= end.getTime(); cur.setUTCDate(cur.getUTCDate() + 1)) {
+    const name = `bridge-${cur.getUTCFullYear().toString().padStart(4, "0")}-${(cur.getUTCMonth() + 1).toString().padStart(2, "0")}-${cur.getUTCDate().toString().padStart(2, "0")}.jsonl`;
+    files.push(name);
+  }
+  return files;
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null;
+}
+function extractItems(lines2, sessionIds) {
+  const sessionSet = new Set(sessionIds);
+  const items = [];
+  let skipped2 = 0;
+  for (const raw of lines2) {
+    if (raw.trim() === "") {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      skipped2++;
+      continue;
+    }
+    if (!isRecord3(parsed)) {
+      skipped2++;
+      continue;
+    }
+    const obj = parsed;
+    if (!sessionSet.has(obj.sessionId)) continue;
+    const ts = obj.ts;
+    const type = obj.type;
+    const payload = obj.payload;
+    if (type === "turn" && isRecord3(payload) && typeof payload.message === "string") {
+      items.push({ ts, kind: "user", text: payload.message });
+    } else if (type === "event" && isRecord3(payload) && isRecord3(payload.event) && payload.event.type === "assistant" && typeof payload.event.content === "string") {
+      items.push({ ts, kind: "assistant", text: payload.event.content });
+    } else if (type === "event" && isRecord3(payload) && isRecord3(payload.event) && payload.event.type === "tool_use" && isRecord3(payload.event.tool) && typeof payload.event.tool.name === "string") {
+      items.push({ ts, kind: "tool", text: payload.event.tool.name });
+    }
+  }
+  items.sort((a, b) => a.ts < b.ts ? -1 : a.ts > b.ts ? 1 : 0);
+  return { items, skipped: skipped2 };
+}
+function renderReseedBlock(items, opts) {
+  const buildText = (kept2, droppedCount) => {
+    const header = [
+      "[bridge:reconstructed-history] The conversation below is a RECONSTRUCTION assembled",
+      "from this bridge's own logs. It is NOT your memory: you did not run these tools in",
+      "this thread, and nothing here is a live handle.",
+      "- Every external session it mentions is GONE: browser tabs, logins, shell sessions,",
+      "  working directories, temporary files.",
+      "- Tool names appear WITHOUT their arguments and WITHOUT their results, and may come",
+      "  from a different provider's tool surface than the one you have now. They are",
+      "  history, not a menu.",
+      "- Before acting on anything described here, re-verify it against current state."
+    ].join("\n");
+    const firstKeptTs = kept2[0]?.ts;
+    const truncationNotice = droppedCount > 0 && firstKeptTs !== void 0 ? `- TRUNCATED: the oldest ${droppedCount} items were dropped; this reconstruction starts at ${firstKeptTs}.` : "";
+    const roleMap = {
+      user: "OPERATOR",
+      assistant: "DIRECTOR",
+      tool: "TOOL"
+    };
+    const itemsText = kept2.map((it) => `[${it.ts}] ${roleMap[it.kind]}: ${it.text}`).join("\n");
+    const body = [
+      truncationNotice,
+      "--- reconstructed conversation begins ---",
+      itemsText,
+      "--- reconstructed conversation ends ---",
+      "The operator's actual request for THIS turn is the LAST block in this message, below",
+      "any project-context or bridge-notice blocks that follow this one."
+    ].filter((s) => s !== "").join("\n");
+    return `${header}
+${body}`;
+  };
+  if (estimateTokens(buildText(items, 0)) <= opts.maxTokens) {
+    return {
+      text: buildText(items, 0),
+      droppedCount: 0,
+      itemCount: items.length
+    };
+  }
+  const kept = [...items];
+  let dropped = 0;
+  const dropOne = () => {
+    const toolIdx = kept.findIndex((it) => it.kind === "tool");
+    kept.splice(toolIdx >= 0 ? toolIdx : 0, 1);
+  };
+  while (kept.length > 0) {
+    dropOne();
+    dropped++;
+    if (kept.length === 0) return null;
+    const candidateText = buildText(kept, dropped);
+    if (estimateTokens(candidateText) <= opts.maxTokens) {
+      const convCount = kept.filter(
+        (it) => it.kind === "user" || it.kind === "assistant"
+      ).length;
+      if (convCount < opts.minConversationalItems) {
+        return null;
+      }
+      return {
+        text: candidateText,
+        droppedCount: dropped,
+        itemCount: kept.length
+      };
+    }
+  }
+  return null;
+}
+var NO_HISTORY_BLOCK = "[bridge:no-history] No prior conversation is available for this chat \u2014 it could not be\nreconstructed. Do NOT infer what was discussed before, and do NOT assume any earlier\ntask is still in progress. If the operator's request below refers to prior context,\nsay plainly that the history is unavailable and ask them to restate what they need.";
+async function readSessionRows(logsDir, files, sessionIds) {
+  const lines2 = [];
+  let missingFiles = 0;
+  for (const f of files) {
+    const filePath = (0, import_node_path22.join)(logsDir, f);
+    try {
+      const stream = (0, import_node_fs15.createReadStream)(filePath, { encoding: "utf8" });
+      const rl = (0, import_node_readline.createInterface)({ input: stream, crlfDelay: Infinity });
+      try {
+        for await (const line of rl) {
+          if (line.trim() === "") continue;
+          if (sessionIds && sessionIds.length > 0 && !sessionIds.some((id) => line.includes(id))) continue;
+          lines2.push(line);
+        }
+      } finally {
+        rl.close();
+        stream.destroy();
+      }
+    } catch (e) {
+      if (isRecord3(e) && e.code === "ENOENT") {
+        missingFiles++;
+        continue;
+      }
+      throw e;
+    }
+  }
+  return { lines: lines2, missingFiles };
+}
+
 // src/external-agents-scrub.ts
-var import_node_fs15 = __toESM(require("node:fs"), 1);
+var import_node_fs16 = __toESM(require("node:fs"), 1);
 var import_node_os10 = __toESM(require("node:os"), 1);
-var import_node_path22 = __toESM(require("node:path"), 1);
+var import_node_path23 = __toESM(require("node:path"), 1);
 var REDACTION = "[REDACTED]";
 var SHORT_VALUE_THRESHOLD = 8;
-var KEYS_ENV_PATH = () => import_node_path22.default.join(import_node_os10.default.homedir(), ".local", "state", "external-agents", "keys.env");
+var KEYS_ENV_PATH = () => import_node_path23.default.join(import_node_os10.default.homedir(), ".local", "state", "external-agents", "keys.env");
 var keysEnvCache = null;
 function readKeysEnv() {
   const filePath = KEYS_ENV_PATH();
   let mtimeMs = 0;
   try {
-    mtimeMs = import_node_fs15.default.statSync(filePath).mtimeMs;
+    mtimeMs = import_node_fs16.default.statSync(filePath).mtimeMs;
   } catch {
     mtimeMs = 0;
   }
@@ -52801,7 +53094,7 @@ function readKeysEnv() {
   }
   const map2 = /* @__PURE__ */ new Map();
   try {
-    const content = import_node_fs15.default.readFileSync(filePath, "utf8");
+    const content = import_node_fs16.default.readFileSync(filePath, "utf8");
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
       if (line === "" || line.startsWith("#")) continue;
@@ -53219,7 +53512,7 @@ function addBridgeModel(target, model) {
 }
 function readTextIfExists(filePath) {
   try {
-    return import_node_fs16.default.readFileSync(filePath, "utf8");
+    return import_node_fs17.default.readFileSync(filePath, "utf8");
   } catch {
     return null;
   }
@@ -53230,9 +53523,9 @@ function readKnownGptSlugsFromTomlFile(filePath) {
   return Array.from(raw.matchAll(/^\s*model\s*=\s*"([^"]+)"/gm)).map((match) => match[1]?.trim() ?? "").filter(isSelectableModelSlug);
 }
 function readCodexFallbackModels() {
-  const codexHome = process.env.CODEX_HOME?.trim() || import_node_path23.default.join(import_node_os11.default.homedir(), ".codex");
+  const codexHome = process.env.CODEX_HOME?.trim() || import_node_path24.default.join(import_node_os11.default.homedir(), ".codex");
   const models = /* @__PURE__ */ new Map();
-  const cachePath = import_node_path23.default.join(codexHome, "models_cache.json");
+  const cachePath = import_node_path24.default.join(codexHome, "models_cache.json");
   const cacheRaw = readTextIfExists(cachePath);
   if (cacheRaw) {
     try {
@@ -53282,7 +53575,7 @@ function readCodexFallbackModels() {
       );
     }
   }
-  for (const slug of readKnownGptSlugsFromTomlFile(import_node_path23.default.join(codexHome, "config.toml"))) {
+  for (const slug of readKnownGptSlugsFromTomlFile(import_node_path24.default.join(codexHome, "config.toml"))) {
     addBridgeModel(
       models,
       mapBridgeModel({
@@ -53296,11 +53589,11 @@ function readCodexFallbackModels() {
       })
     );
   }
-  const automationsDir = import_node_path23.default.join(codexHome, "automations");
+  const automationsDir = import_node_path24.default.join(codexHome, "automations");
   try {
-    for (const entry of import_node_fs16.default.readdirSync(automationsDir, { withFileTypes: true })) {
+    for (const entry of import_node_fs17.default.readdirSync(automationsDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      for (const slug of readKnownGptSlugsFromTomlFile(import_node_path23.default.join(automationsDir, entry.name, "automation.toml"))) {
+      for (const slug of readKnownGptSlugsFromTomlFile(import_node_path24.default.join(automationsDir, entry.name, "automation.toml"))) {
         addBridgeModel(
           models,
           mapBridgeModel({
@@ -53319,10 +53612,16 @@ function readCodexFallbackModels() {
   }
   return [...models.values()];
 }
+function selfUpdateInboxItemId(offeredVersion) {
+  if (!offeredVersion) return `II-MCPUPD-${(0, import_node_crypto9.randomUUID)()}`;
+  if (/^[A-Za-z0-9._-]+$/.test(offeredVersion)) return `II-MCPUPD-${offeredVersion}`;
+  const hash3 = import_node_crypto9.default.createHash("sha256").update(offeredVersion).digest("hex").slice(0, 10);
+  return `II-MCPUPD-${offeredVersion.replace(/[^A-Za-z0-9._-]/g, "-")}-${hash3}`;
+}
 function neutralCheckoutCwd(stateDir) {
-  const dir = import_node_path23.default.join(stateDir, "no-checkout");
+  const dir = import_node_path24.default.join(stateDir, "no-checkout");
   try {
-    import_node_fs16.default.mkdirSync(dir, { recursive: true });
+    import_node_fs17.default.mkdirSync(dir, { recursive: true });
   } catch {
   }
   return dir;
@@ -53752,7 +54051,7 @@ async function runOrphanWorktreeSweep(client, opts) {
   const cutoff = Date.now() - worktreeRetentionMs();
   const isReapable = (worktreePath) => {
     try {
-      return import_node_fs16.default.statSync(worktreePath).mtimeMs < cutoff;
+      return import_node_fs17.default.statSync(worktreePath).mtimeMs < cutoff;
     } catch {
       return false;
     }
@@ -53790,8 +54089,8 @@ async function runOrphanWorktreeSweep(client, opts) {
   }
 }
 function readStateDir() {
-  if (process.env.CODEX_HOME) return import_node_path23.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
-  return import_node_path23.default.join(import_node_os11.default.homedir(), ".mrrlin", "director-bridge");
+  if (process.env.CODEX_HOME) return import_node_path24.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge");
+  return import_node_path24.default.join(import_node_os11.default.homedir(), ".mrrlin", "director-bridge");
 }
 function readAllowedOrigins() {
   const raw = (process.env.MRRLIN_DIRECTOR_BRIDGE_ALLOWED_ORIGINS ?? "").trim();
@@ -54001,7 +54300,7 @@ function describeZeroOutputLimit(signal) {
 }
 function createBridgeMessageHandler(deps) {
   const tombstones = deps.tombstones ?? /* @__PURE__ */ new Map();
-  const pendingTurnSessions = /* @__PURE__ */ new Set();
+  const pendingTurnSessions = deps.pendingTurnSessions ?? /* @__PURE__ */ new Set();
   return (socket, _request, send, logCtx) => {
     const boundSessions = /* @__PURE__ */ new Set();
     socket.on("close", () => {
@@ -54675,6 +54974,7 @@ function createBridgeMessageHandler(deps) {
       const desiredModel = normalizeModel(msg.model);
       const desiredEffort = normalizeReasoningEffort(msg.reasoningEffort);
       const resolvedProviderId = turnSeat.id;
+      let startedFreshThread = false;
       try {
         const startParams = deps.buildStartParams(msg, desiredModel);
         if (!thread) {
@@ -54694,6 +54994,7 @@ function createBridgeMessageHandler(deps) {
           thread = newThread;
           deps.threads.set(directorSessionId, thread);
           deps.persistThreads();
+          startedFreshThread = true;
         } else {
           const existingThread = thread;
           const providerMismatch = existingThread.provider !== null && existingThread.provider !== resolvedProviderId;
@@ -54712,16 +55013,7 @@ function createBridgeMessageHandler(deps) {
           }
           existingThread.threadId = result.threadId;
           existingThread.provider = resolvedProviderId;
-          if (!resumed) {
-            sendForSpan({
-              type: "event",
-              directorSessionId,
-              event: {
-                type: "error",
-                content: "Previous Director thread expired; started a fresh local thread for this chat."
-              }
-            });
-          }
+          if (!resumed) startedFreshThread = true;
           existingThread.model = desiredModel;
           existingThread.reasoningEffort = desiredEffort;
         }
@@ -54764,6 +55056,16 @@ function createBridgeMessageHandler(deps) {
         directorSessionId,
         turnId: thread.replay.turnId
       });
+      if (startedFreshThread) {
+        sendForSpan({
+          type: "event",
+          directorSessionId,
+          event: {
+            type: "notice",
+            content: "This chat's previous Director thread is gone; continuing on a fresh thread. Earlier context is reconstructed from the bridge log where possible."
+          }
+        });
+      }
       const contextFocusTaskId = msg.context?.focusTaskId?.trim();
       const contextProjectSlug = msg.context?.projectSlug?.trim();
       let answeredQuestions;
@@ -54936,9 +55238,22 @@ function createBridgeMessageHandler(deps) {
               if (updateOffer !== null && updateOfferProjectSlug && deps.fileUpdateInboxItem) {
                 void deps.fileUpdateInboxItem(updateOfferProjectSlug);
               }
-              const composedPrefix = updateOffer ? contextPrefix ? `${updateOffer}
-
-${contextPrefix}` : updateOffer : contextPrefix;
+              let reseedPrefix = null;
+              if (startedFreshThread && deps.buildReseedPrefix) {
+                const otherBytes = Buffer.byteLength(contextPrefix ?? "", "utf8") + Buffer.byteLength(updateOffer ?? "", "utf8") + Buffer.byteLength(effectiveText, "utf8");
+                try {
+                  reseedPrefix = await deps.buildReseedPrefix({
+                    directorSessionId,
+                    // Client-supplied, so the elements are validated and not just the shape:
+                    // this array selects which sessions' log rows get replayed into a prompt.
+                    priorSessionIds: Array.isArray(msg.priorSessionIds) ? msg.priorSessionIds.filter((id) => typeof id === "string" && id.length > 0) : [],
+                    otherBytes
+                  });
+                } catch {
+                  reseedPrefix = null;
+                }
+              }
+              const composedPrefix = [reseedPrefix, contextPrefix, updateOffer].filter((part) => typeof part === "string" && part.length > 0).join("\n\n");
               const composed = composedPrefix ? `${composedPrefix}
 
 ${effectiveText}` : effectiveText;
@@ -55039,6 +55354,7 @@ function sweepIdleThreads(threads, opts) {
   const reaped = [];
   for (const [directorSessionId, thread] of threads.entries()) {
     if (thread.inFlight) continue;
+    if (opts.isPending?.(directorSessionId)) continue;
     if (thread.replay && !shouldGc(thread.replay, opts.now, suspendedNow)) continue;
     if (thread.supersededReplay && !shouldGc(thread.supersededReplay, opts.now, suspendedNow)) continue;
     if (!shouldReapIdleThread(thread, opts.now, suspendedNow, opts.idleThreadTtlMs)) continue;
@@ -55047,6 +55363,25 @@ function sweepIdleThreads(threads, opts) {
   }
   return reaped;
 }
+function evictOverflowThreads(threads, opts) {
+  if (threads.size <= opts.maxThreads) return [];
+  const suspendedNow = opts.suspendedMs();
+  const evictable = [...threads.entries()].filter(([directorSessionId, thread]) => {
+    if (thread.inFlight) return false;
+    if (opts.isPending?.(directorSessionId)) return false;
+    if (thread.replay && !shouldGc(thread.replay, opts.now, suspendedNow)) return false;
+    if (thread.supersededReplay && !shouldGc(thread.supersededReplay, opts.now, suspendedNow)) return false;
+    return true;
+  }).sort((a, b) => a[1].lastUsedAt - b[1].lastUsedAt);
+  const overflow = threads.size - opts.maxThreads;
+  const evicted = [];
+  for (const [directorSessionId] of evictable) {
+    if (evicted.length >= overflow) break;
+    threads.delete(directorSessionId);
+    evicted.push(directorSessionId);
+  }
+  return evicted;
+}
 function sweepReplayBuffers(threads, tombstones, opts) {
   const suspendedNow = opts.suspendedMs();
   let retainedBuffers = 0;
@@ -55088,8 +55423,25 @@ function parseConfig() {
   const token = readOrCreateBridgeToken(stateDir);
   const codexCwd = process.env.MRRLIN_DIRECTOR_BRIDGE_CODEX_CWD?.trim() || void 0;
   const codexExecutable = process.env.MRRLIN_DIRECTOR_BRIDGE_CODEX_BIN?.trim() || void 0;
-  const idleThreadTtlMs = Math.max(6e4, readEnvInt("MRRLIN_DIRECTOR_BRIDGE_IDLE_TTL_SECONDS", 1800) * 1e3);
-  return { host, port, stateDir, allowedOrigins, token, codexCwd, codexExecutable, idleThreadTtlMs };
+  const idleThreadTtlMs = Math.max(6e4, readEnvInt("MRRLIN_DIRECTOR_BRIDGE_IDLE_TTL_SECONDS", 172800) * 1e3);
+  const maxThreads = Math.max(1, readEnvInt("MRRLIN_DIRECTOR_BRIDGE_MAX_THREADS", 128));
+  const reseedMaxTokens = Math.max(1e3, readEnvInt("MRRLIN_DIRECTOR_BRIDGE_RESEED_MAX_TOKENS", 48e3));
+  const turnMaxTokens = Math.max(reseedMaxTokens, readEnvInt("MRRLIN_DIRECTOR_BRIDGE_TURN_MAX_TOKENS", 64e3));
+  const reseedMinItems = Math.max(0, readEnvInt("MRRLIN_DIRECTOR_BRIDGE_RESEED_MIN_ITEMS", 4));
+  return {
+    host,
+    port,
+    stateDir,
+    allowedOrigins,
+    token,
+    codexCwd,
+    codexExecutable,
+    idleThreadTtlMs,
+    maxThreads,
+    reseedMaxTokens,
+    turnMaxTokens,
+    reseedMinItems
+  };
 }
 function scanForOtherBridges() {
   try {
@@ -55102,11 +55454,15 @@ function scanForOtherBridges() {
     return [];
   }
 }
+function checkTelemetryDefaultProject(env, warn) {
+  if (env.MRRLIN_TELEMETRY_DEFAULT_PROJECT?.trim()) return;
+  warn(
+    "[mrrlin-mcp director-bridge] MRRLIN_TELEMETRY_DEFAULT_PROJECT is not set \u2014 telemetry for turns with no project-scoped tool call will not be uploaded. Set it in the pm2 ecosystem config to enable unattributed telemetry upload."
+  );
+}
 async function startDirectorBridge() {
   const config2 = parseConfig();
-  if (!process.env.MRRLIN_TELEMETRY_DEFAULT_PROJECT?.trim()) {
-    throw new Error("MRRLIN_TELEMETRY_DEFAULT_PROJECT must be set (non-empty) at bridge startup.");
-  }
+  checkTelemetryDefaultProject(process.env, (m) => console.error(m));
   const turnLock = createTurnLock();
   let lastTurnEndedAt = Date.now();
   const wrappedTurnLock = {
@@ -55243,8 +55599,8 @@ async function startDirectorBridge() {
     codexCwd: config2.codexCwd,
     codexExecutable: config2.codexExecutable,
     checkoutRegistry,
-    worktreeRoot: import_node_path23.default.join(config2.stateDir, "worktrees"),
-    locksDir: import_node_path23.default.join(config2.stateDir, "locks"),
+    worktreeRoot: import_node_path24.default.join(config2.stateDir, "worktrees"),
+    locksDir: import_node_path24.default.join(config2.stateDir, "locks"),
     // Wire the executor server for code-execution runs. Each run gets its own provider process
     // (app-server for codex, a resident CLI child for claude) at the run worktree, running
     // UNRESTRICTED from the real operator config (owner no-sandbox decision — auth + mrrlin MCP
@@ -55288,13 +55644,13 @@ async function startDirectorBridge() {
         // egressDomains is retained in the seam signature (verification-turn.ts still computes the
         // env host) but no longer constrains anything — the executor is unrestricted.
         startSandbox: async (_egressDomains, providerId) => {
-          const cwd = import_node_fs16.default.mkdtempSync(import_node_path23.default.join(import_node_os11.default.tmpdir(), "mrrlin-verify-"));
+          const cwd = import_node_fs17.default.mkdtempSync(import_node_path24.default.join(import_node_os11.default.tmpdir(), "mrrlin-verify-"));
           let executor;
           try {
             executor = await startExecutorServer({ worktree: cwd, provider: providerId });
           } catch (error51) {
             try {
-              import_node_fs16.default.rmSync(cwd, { recursive: true, force: true });
+              import_node_fs17.default.rmSync(cwd, { recursive: true, force: true });
             } catch {
             }
             throw error51;
@@ -55305,7 +55661,7 @@ async function startDirectorBridge() {
             dispose: () => {
               executor.dispose();
               try {
-                import_node_fs16.default.rmSync(cwd, { recursive: true, force: true });
+                import_node_fs17.default.rmSync(cwd, { recursive: true, force: true });
               } catch {
               }
             }
@@ -55450,18 +55806,94 @@ async function startDirectorBridge() {
       );
     }
   };
+  const pendingTurnSessions = /* @__PURE__ */ new Set();
   const cleanupTimer = setInterval(() => {
+    const now = Date.now();
+    const isPending = (directorSessionId) => pendingTurnSessions.has(directorSessionId);
     const reaped = sweepIdleThreads(threads, {
-      now: Date.now(),
+      now,
+      suspendedMs: () => suspensionDetector.suspendedMs(),
+      idleThreadTtlMs: config2.idleThreadTtlMs,
+      isPending
+    });
+    const evicted = evictOverflowThreads(threads, {
+      now,
       suspendedMs: () => suspensionDetector.suspendedMs(),
-      idleThreadTtlMs: config2.idleThreadTtlMs
+      maxThreads: config2.maxThreads,
+      isPending
     });
-    if (reaped.length > 0) persistThreads();
+    for (const sessionId of reaped) {
+      bridgeLogger.logOut({ spanId: "gc", sessionId, type: "<thread-evicted>", payload: { sessionId, reason: "age" } });
+    }
+    for (const sessionId of evicted) {
+      bridgeLogger.logOut({
+        spanId: "gc",
+        sessionId,
+        type: "<thread-evicted>",
+        payload: { sessionId, reason: "count", mapSize: threads.size, maxThreads: config2.maxThreads }
+      });
+    }
+    if (reaped.length > 0 || evicted.length > 0) persistThreads();
   }, 6e4);
   cleanupTimer.unref?.();
   let remoteRelay = null;
   const relayUrl = process.env.MRRLIN_RELAY_URL?.trim();
   const relayConfigured = Boolean(agentSecret && relayUrl);
+  const buildReseedPrefix = async (args) => {
+    const refuse = (reason) => {
+      bridgeLogger.logOut({
+        spanId: "reseed",
+        sessionId: args.directorSessionId,
+        type: "<reseed>",
+        payload: { sessionId: args.directorSessionId, refused: reason }
+      });
+      return NO_HISTORY_BLOCK;
+    };
+    if (!resolveBridgeLogEnabled()) return refuse("log-disabled");
+    if (!resolvePromptsEnabled()) return refuse("prompts-not-logged");
+    const retentionWindowMs = readEnvInt("MRRLIN_LOG_RETENTION_AGE_DAYS", 30) * 864e5;
+    const reseedWindowMs = Math.min(config2.idleThreadTtlMs, retentionWindowMs);
+    if (reseedWindowMs < config2.idleThreadTtlMs) {
+      bridgeLogger.logOut({
+        spanId: "reseed",
+        sessionId: args.directorSessionId,
+        type: "<reseed-window-clamped>",
+        payload: {
+          idleThreadTtlMs: config2.idleThreadTtlMs,
+          retentionWindowMs,
+          effectiveWindowMs: reseedWindowMs
+        }
+      });
+    }
+    const files = dayFilesInWindow(/* @__PURE__ */ new Date(), reseedWindowMs);
+    const sessionIds = [args.directorSessionId, ...args.priorSessionIds];
+    const { lines: lines2, missingFiles } = await readSessionRows(import_node_path24.default.join(config2.stateDir, "logs"), files, sessionIds);
+    const { items, skipped: skipped2 } = extractItems(lines2, sessionIds);
+    if (items.length === 0) return refuse("no-rows");
+    const budget = Math.max(0, Math.min(config2.reseedMaxTokens, config2.turnMaxTokens - args.otherBytes));
+    const block = renderReseedBlock(items, {
+      maxTokens: budget,
+      minConversationalItems: config2.reseedMinItems
+    });
+    if (!block) return refuse("below-minimum-after-truncation");
+    bridgeLogger.logOut({
+      spanId: "reseed",
+      sessionId: args.directorSessionId,
+      type: "<reseed>",
+      payload: {
+        sessionId: args.directorSessionId,
+        priorSessionIds: args.priorSessionIds.length,
+        dayFiles: files.length,
+        missingFiles,
+        parseSkips: skipped2,
+        itemCount: block.itemCount,
+        droppedCount: block.droppedCount,
+        estimatedTokens: Buffer.byteLength(block.text, "utf8"),
+        budget
+      }
+    });
+    return block.text;
+  };
   const sharedHandlerDeps = {
     acquireCodex: (providerId) => agentKeepalive.acquire(providerId),
     releaseCodex: (providerId) => agentKeepalive.release(providerId),
@@ -55490,7 +55922,7 @@ async function startDirectorBridge() {
     fileUpdateInboxItem: async (projectSlug) => {
       const body = selfUpdateHandle.updateInboxBody();
       if (!body) return;
-      const id = `II-MCPUPD-${(0, import_node_crypto9.randomUUID)()}`;
+      const id = selfUpdateInboxItemId(selfUpdateHandle.getLatestVersion());
       try {
         const row = await client.createInboxItem(projectSlug, { id, kind: "info", body });
         process.stderr.write(
@@ -55532,13 +55964,21 @@ async function startDirectorBridge() {
   const bridgeLogger = createBridgeLogger(config2.stateDir, process.env);
   let bridgeBinShaShort = "unknown00000";
   try {
-    bridgeBinShaShort = import_node_crypto9.default.createHash("sha256").update(import_node_fs16.default.readFileSync(process.argv[1] ?? "")).digest("hex").slice(0, 12);
+    bridgeBinShaShort = import_node_crypto9.default.createHash("sha256").update(import_node_fs17.default.readFileSync(process.argv[1] ?? "")).digest("hex").slice(0, 12);
   } catch {
   }
   attachBridgeWss(server, {
     token: config2.token,
     allowedOrigins: config2.allowedOrigins,
-    onReady: createBridgeMessageHandler({ ...sharedHandlerDeps, threads, persistThreads, bridgeInstanceId, tombstones }),
+    onReady: createBridgeMessageHandler({
+      ...sharedHandlerDeps,
+      threads,
+      persistThreads,
+      bridgeInstanceId,
+      tombstones,
+      pendingTurnSessions,
+      buildReseedPrefix
+    }),
     logger: bridgeLogger,
     onPaired: () => health.setPaired(true),
     bridgeInstanceId,
@@ -55659,8 +56099,8 @@ async function startDirectorBridge() {
       );
       void runOrphanWorktreeSweep(client, {
         checkoutRegistry,
-        worktreeRoot: import_node_path23.default.join(config2.stateDir, "worktrees"),
-        locksDir: import_node_path23.default.join(config2.stateDir, "locks")
+        worktreeRoot: import_node_path24.default.join(config2.stateDir, "worktrees"),
+        locksDir: import_node_path24.default.join(config2.stateDir, "locks")
       });
       {
         const { retainedBuffers, retainedBytes, tombstonesRemoved } = sweepReplayBuffers(threads, tombstones, {
@@ -55710,10 +56150,24 @@ async function startDirectorBridge() {
             codexExecutable: config2.codexExecutable,
             timeoutMs: readEnvInt("MRRLIN_TELEMETRY_GATE_TIMEOUT_SECONDS", 60) * 1e3
           });
-          await prune(config2.stateDir, {
+          const pruneResult = await prune(config2.stateDir, {
             ageDays: readEnvInt("MRRLIN_LOG_RETENTION_AGE_DAYS", 30),
-            budgetMb: readEnvInt("MRRLIN_LOG_RETENTION_BUDGET_MB", 1024)
+            budgetMb: readEnvInt("MRRLIN_LOG_RETENTION_BUDGET_MB", 1024),
+            // The reconstruction window's day-files are off limits. Derived from the thread
+            // TTL so the two numbers cannot drift apart.
+            protectedSinceMs: Date.now() - config2.idleThreadTtlMs
           });
+          if (pruneResult.budgetOvershootBytes > 0) {
+            bridgeLogger.logOut({
+              spanId: "gc",
+              sessionId: null,
+              type: "<log-budget-overshoot>",
+              payload: {
+                overshootBytes: pruneResult.budgetOvershootBytes,
+                reason: "protected re-seed window not pruned"
+              }
+            });
+          }
         } catch (error51) {
           bridgeLogger.logOut({
             spanId: "gc",
@@ -55965,15 +56419,15 @@ function readDispatchBody(req) {
 function readOrCreateBridgeToken(stateDir) {
   const explicit = (process.env.MRRLIN_DIRECTOR_BRIDGE_TOKEN ?? "").trim();
   if (explicit) return explicit;
-  const tokenPath = import_node_path23.default.join(stateDir, "token.txt");
+  const tokenPath = import_node_path24.default.join(stateDir, "token.txt");
   try {
-    const existing = import_node_fs16.default.readFileSync(tokenPath, "utf8").trim();
+    const existing = import_node_fs17.default.readFileSync(tokenPath, "utf8").trim();
     if (existing) return existing;
   } catch {
   }
-  import_node_fs16.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
+  import_node_fs17.default.mkdirSync(stateDir, { recursive: true, mode: 448 });
   const token = import_node_crypto9.default.randomBytes(32).toString("base64url");
-  import_node_fs16.default.writeFileSync(tokenPath, `${token}
+  import_node_fs17.default.writeFileSync(tokenPath, `${token}
 `, { mode: 384 });
   return token;
 }
@@ -59359,15 +59813,15 @@ var StdioServerTransport = class {
 // src/tools.ts
 var import_node_crypto12 = require("node:crypto");
 var import_promises10 = require("node:fs/promises");
-var import_node_path26 = __toESM(require("node:path"), 1);
+var import_node_path27 = __toESM(require("node:path"), 1);
 var import_node_os12 = __toESM(require("node:os"), 1);
 
 // ../../packages/wiki/dist/index.js
 var import_promises8 = __toESM(require("node:fs/promises"), 1);
-var import_node_path24 = __toESM(require("node:path"), 1);
+var import_node_path25 = __toESM(require("node:path"), 1);
 var INCLUDED_DOC_FOLDERS = /* @__PURE__ */ new Set(["_meta", "explanation", "how-to", "reference", "sdd", "tutorials"]);
 function toPosixPath(input) {
-  return input.split(import_node_path24.default.sep).join("/");
+  return input.split(import_node_path25.default.sep).join("/");
 }
 function slugifyWikiSegment(input) {
   return input.trim().toLowerCase().replace(/`/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
@@ -59381,12 +59835,12 @@ async function pathExists3(input) {
   }
 }
 async function findWorkspaceRoot(start = process.cwd()) {
-  let current2 = import_node_path24.default.resolve(start);
+  let current2 = import_node_path25.default.resolve(start);
   while (true) {
-    if (await pathExists3(import_node_path24.default.join(current2, "pnpm-workspace.yaml")) && await pathExists3(import_node_path24.default.join(current2, "docs"))) {
+    if (await pathExists3(import_node_path25.default.join(current2, "pnpm-workspace.yaml")) && await pathExists3(import_node_path25.default.join(current2, "docs"))) {
       return current2;
     }
-    const parent = import_node_path24.default.dirname(current2);
+    const parent = import_node_path25.default.dirname(current2);
     if (parent === current2) {
       throw new Error(`Unable to find Mrrlin workspace root from ${start}`);
     }
@@ -59395,28 +59849,28 @@ async function findWorkspaceRoot(start = process.cwd()) {
 }
 async function resolveDocsRoot(input) {
   if (input) {
-    return import_node_path24.default.resolve(input);
+    return import_node_path25.default.resolve(input);
   }
   if (process.env.MRRLIN_DOCS_ROOT) {
-    return import_node_path24.default.resolve(process.env.MRRLIN_DOCS_ROOT);
+    return import_node_path25.default.resolve(process.env.MRRLIN_DOCS_ROOT);
   }
-  return import_node_path24.default.join(await findWorkspaceRoot(), "docs");
+  return import_node_path25.default.join(await findWorkspaceRoot(), "docs");
 }
 async function resolveIndexPath(input) {
   if (input) {
-    return import_node_path24.default.resolve(input);
+    return import_node_path25.default.resolve(input);
   }
   if (process.env.MRRLIN_WIKI_INDEX_PATH) {
-    return import_node_path24.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
+    return import_node_path25.default.resolve(process.env.MRRLIN_WIKI_INDEX_PATH);
   }
   const workspaceRoot = await findWorkspaceRoot();
-  return import_node_path24.default.join(workspaceRoot, "apps", "web", "public", "wiki-index.json");
+  return import_node_path25.default.join(workspaceRoot, "apps", "web", "public", "wiki-index.json");
 }
 async function walkMarkdownFiles(root, dir = root) {
   const entries = await import_promises8.default.readdir(dir, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const absolute = import_node_path24.default.join(dir, entry.name);
+    const absolute = import_node_path25.default.join(dir, entry.name);
     if (entry.isDirectory()) {
       files.push(...await walkMarkdownFiles(root, absolute));
       continue;
@@ -59435,7 +59889,7 @@ function parseTitle(markdown, sourcePath) {
   return title;
 }
 function documentFromFile(docsRoot, absolutePath, markdown) {
-  const relativePath = toPosixPath(import_node_path24.default.relative(docsRoot, absolutePath));
+  const relativePath = toPosixPath(import_node_path25.default.relative(docsRoot, absolutePath));
   const [section, fileName] = relativePath.split("/");
   if (!section || !fileName || !INCLUDED_DOC_FOLDERS.has(section)) {
     return null;
@@ -60941,17 +61395,17 @@ var intentCheckDescriptor = createIntentCheckDescriptor();
 
 // src/evidence/assembler.ts
 var import_promises9 = require("node:fs/promises");
-var import_node_path25 = require("node:path");
+var import_node_path26 = require("node:path");
 function evidenceDedupKey(sessionId, reportId) {
   return `${sessionId}:${reportId}`;
 }
-function isRecord3(v) {
+function isRecord4(v) {
   return v !== null && typeof v === "object";
 }
 async function readDayLines(stateDir, day, sessionId) {
   let raw;
   try {
-    raw = await (0, import_promises9.readFile)((0, import_node_path25.join)(stateDir, "logs", `bridge-${day}.jsonl`), "utf8");
+    raw = await (0, import_promises9.readFile)((0, import_node_path26.join)(stateDir, "logs", `bridge-${day}.jsonl`), "utf8");
   } catch {
     return [];
   }
@@ -60964,7 +61418,7 @@ async function readDayLines(stateDir, day, sessionId) {
     } catch {
       continue;
     }
-    if (!isRecord3(rec) || !isRecord3(rec.payload)) continue;
+    if (!isRecord4(rec) || !isRecord4(rec.payload)) continue;
     if (rec.payload.directorSessionId !== sessionId) continue;
     kept.push(rec);
   }
@@ -61025,7 +61479,7 @@ async function assembleEvidence(stateDir, sessionId, reportId, gateCtx) {
   }
   let windowPruned = false;
   try {
-    const raw = await (0, import_promises9.readFile)((0, import_node_path25.join)(stateDir, "logs", ".pruned.jsonl"), "utf8");
+    const raw = await (0, import_promises9.readFile)((0, import_node_path26.join)(stateDir, "logs", ".pruned.jsonl"), "utf8");
     outer: for (const line of raw.split("\n")) {
       if (!line.trim()) continue;
       let rec;
@@ -61034,7 +61488,7 @@ async function assembleEvidence(stateDir, sessionId, reportId, gateCtx) {
       } catch {
         continue;
       }
-      if (!isRecord3(rec) || !Array.isArray(rec.daysRemoved)) continue;
+      if (!isRecord4(rec) || !Array.isArray(rec.daysRemoved)) continue;
       for (const removedDay of rec.daysRemoved) {
         if (daysRead.includes(removedDay)) {
           windowPruned = true;
@@ -62758,7 +63212,7 @@ function createMrrlinTools(options) {
       "ARTIFACT_FILE_UPLOAD_FAILED",
       "Unable to upload artifact file.",
       async (c, { projectSlug, path: filePath, class: artifactClass, taskId, runId, description }) => {
-        const extension2 = import_node_path26.default.extname(filePath).toLowerCase();
+        const extension2 = import_node_path27.default.extname(filePath).toLowerCase();
         const contentType = ARTIFACT_EXTENSION_TYPES[extension2];
         if (!contentType) {
           throw new McpToolCodedError(
@@ -62786,7 +63240,7 @@ function createMrrlinTools(options) {
             "Artifact exceeds 5MB; split or summarize instead."
           );
         }
-        const filename = import_node_path26.default.basename(filePath);
+        const filename = import_node_path27.default.basename(filePath);
         return uploadArtifactBytes(c, {
           bytes: bytes3,
           class: artifactClass,
@@ -62811,7 +63265,7 @@ function createMrrlinTools(options) {
             `Invalid filename '${filename}'; provide a bare filename with no path separators or '..'.`
           );
         }
-        const extension2 = import_node_path26.default.extname(filename).toLowerCase();
+        const extension2 = import_node_path27.default.extname(filename).toLowerCase();
         const contentType = ARTIFACT_EXTENSION_TYPES[extension2];
         if (!contentType) {
           throw new McpToolCodedError(
@@ -62878,7 +63332,7 @@ function createMrrlinTools(options) {
       "LOCAL_CHECKOUT_REGISTER_FAILED",
       "Unable to register local checkout.",
       async (_c, { projectSlug, path: checkoutPath, repo }) => {
-        const stateDir = process.env.CODEX_HOME ? import_node_path26.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path26.default.join(import_node_os12.default.homedir(), ".mrrlin", "director-bridge");
+        const stateDir = process.env.CODEX_HOME ? import_node_path27.default.join(process.env.CODEX_HOME, "mrrlin", "director-bridge") : import_node_path27.default.join(import_node_os12.default.homedir(), ".mrrlin", "director-bridge");
         const registry3 = new CheckoutRegistry(stateDir);
         const result = registerCheckout(registry3, { projectSlug, path: checkoutPath, repo }, import_node_os12.default.hostname());
         if (!result.ok) {
@@ -63118,7 +63572,7 @@ function runSetCredential(args) {
 
 // src/install-service.ts
 var import_node_os13 = __toESM(require("node:os"), 1);
-var import_node_path27 = __toESM(require("node:path"), 1);
+var import_node_path28 = __toESM(require("node:path"), 1);
 function installService(deps) {
   if (!deps.hasSecret()) {
     deps.log("No agent credential found. Issue one in Settings, then run: mrrlin-mcp set-credential '<secret>'.");
@@ -63140,7 +63594,7 @@ function installService(deps) {
     return { ok: false };
   }
   const resolvedBins = bins.filter((b) => b !== null);
-  const pathEnv = Array.from(new Set(resolvedBins.map((b) => import_node_path27.default.dirname(b)))).join(":");
+  const pathEnv = Array.from(new Set(resolvedBins.map((b) => import_node_path28.default.dirname(b)))).join(":");
   const apiBaseUrl = deps.env.MRRLIN_API_BASE_URL?.trim() || void 0;
   const staging = deps.env.MRRLIN_STAGING === "1" || !apiBaseUrl && bridgeUrlImpliesStaging(deps.env.MRRLIN_BRIDGE_URL);
   const text = renderEcosystemConfig({
@@ -63151,7 +63605,7 @@ function installService(deps) {
     staging,
     apiBaseUrl
   });
-  const ecoPath = import_node_path27.default.join(home, ".mrrlin", "ecosystem.config.cjs");
+  const ecoPath = import_node_path28.default.join(home, ".mrrlin", "ecosystem.config.cjs");
   deps.writeFile(ecoPath, text);
   const start = deps.runPm2(["startOrReload", ecoPath]);
   if (start.code !== 0) {
@@ -63163,8 +63617,29 @@ function installService(deps) {
     deps.log(`pm2 save failed (exit ${save.code}).`);
     return { ok: false };
   }
-  deps.log(`Service installed (${ecoPath}). For reboot persistence run the printed 'pm2 startup' line ONCE, then reboot and verify 'pm2 status' shows mrrlin-bridge online. If pm2 startup does not stick on macOS, see the runbook's launchd-plist fallback.`);
+  deps.log(`Service installed (${ecoPath}).`);
   deps.runPm2(["startup"]);
+  const hook = deps.bootHookStatus?.();
+  switch (hook?.status) {
+    case void 0:
+      break;
+    case "configured":
+      deps.log(`Boot hook registered (${hook.label}); last run clean.`);
+      break;
+    case "registered_failing":
+      deps.log(
+        `Boot hook registered (${hook.label}) but FAILING - last exit code ${hook.lastExitCode}. The bridge will NOT come back after a reboot. See docs/how-to/run-director-bridge.md.`
+      );
+      break;
+    case "not_configured":
+      deps.log(
+        "No boot hook registered - the bridge will NOT restart after a reboot. See docs/how-to/run-director-bridge.md."
+      );
+      break;
+    case "unknown":
+      deps.log("Boot-hook status not checked on this platform.");
+      break;
+  }
   return { ok: true };
 }
 function uninstallService(deps) {
@@ -63183,12 +63658,12 @@ function uninstallService(deps) {
 // src/uninstall-codex.ts
 var import_promises11 = __toESM(require("node:fs/promises"), 1);
 var import_node_os14 = __toESM(require("node:os"), 1);
-var import_node_path28 = __toESM(require("node:path"), 1);
+var import_node_path29 = __toESM(require("node:path"), 1);
 var toml3 = __toESM(require_toml(), 1);
 function resolveCodexHome3(options) {
   if (options.codexHome) return options.codexHome;
   if (process.env.CODEX_HOME) return process.env.CODEX_HOME;
-  return import_node_path28.default.join(options.homeDir ?? import_node_os14.default.homedir(), ".codex");
+  return import_node_path29.default.join(options.homeDir ?? import_node_os14.default.homedir(), ".codex");
 }
 async function pathExists4(target) {
   try {
@@ -63201,7 +63676,7 @@ async function pathExists4(target) {
 var MRRLIN_BLOCK_RE = /(^|\n)\[mcp_servers\.(?:mrrlin(?:-browser)?|external-agents)(?:\]|\.[^\]\n]*\])[\s\S]*?(?=\n\[|$)/g;
 async function uninstallCodex(options = {}) {
   const codexHome = resolveCodexHome3(options);
-  const configPath = import_node_path28.default.join(codexHome, "config.toml");
+  const configPath = import_node_path29.default.join(codexHome, "config.toml");
   const removePrompts = async () => uninstallPrompts(codexHome, options.promptNames ?? []);
   if (!await pathExists4(configPath)) {
     return { action: "missing", configPath, prompts: await removePrompts() };
@@ -63229,10 +63704,10 @@ async function uninstallCodex(options = {}) {
 }
 async function uninstallPrompts(codexHome, names) {
   if (names.length === 0) return [];
-  const promptsDir = import_node_path28.default.join(codexHome, "prompts");
+  const promptsDir = import_node_path29.default.join(codexHome, "prompts");
   const out = [];
   for (const name of names) {
-    const promptPath = import_node_path28.default.join(promptsDir, `${name}.md`);
+    const promptPath = import_node_path29.default.join(promptsDir, `${name}.md`);
     try {
       await import_promises11.default.unlink(promptPath);
       out.push({ name, action: "removed", promptPath });
@@ -63250,7 +63725,7 @@ async function uninstallPrompts(codexHome, names) {
 
 // src/extract/command.ts
 var import_promises12 = require("node:fs/promises");
-var import_node_path29 = require("node:path");
+var import_node_path30 = require("node:path");
 function parseArgs(args) {
   const map2 = /* @__PURE__ */ new Map();
   for (let i = 0; i < args.length; i++) {
@@ -63266,7 +63741,7 @@ function parseArgs(args) {
   }
   return map2;
 }
-function isRecord4(v) {
+function isRecord5(v) {
   return v !== null && typeof v === "object";
 }
 async function runExtract(args, deps) {
@@ -63287,7 +63762,7 @@ Missing required flag(s): ${missing.join(
   const days = await findSessionDays(deps.stateDir, sessionId);
   const matchingLines = [];
   for (const day of days) {
-    const logPath = (0, import_node_path29.join)(deps.stateDir, "logs", `bridge-${day}.jsonl`);
+    const logPath = (0, import_node_path30.join)(deps.stateDir, "logs", `bridge-${day}.jsonl`);
     let raw;
     try {
       raw = await (0, import_promises12.readFile)(logPath, "utf8");
@@ -63303,8 +63778,8 @@ Missing required flag(s): ${missing.join(
       } catch {
         continue;
       }
-      const payload = isRecord4(parsed) ? parsed.payload : void 0;
-      if (isRecord4(payload) && payload.directorSessionId === sessionId) {
+      const payload = isRecord5(parsed) ? parsed.payload : void 0;
+      if (isRecord5(payload) && payload.directorSessionId === sessionId) {
         matchingLines.push(line);
       }
     }
@@ -63383,6 +63858,29 @@ function whichBin(bin) {
   const out = (r.stdout ?? "").trim();
   return r.status === 0 && out ? out.split("\n")[0] ?? null : null;
 }
+function bootHookStatus() {
+  if (process.platform !== "darwin") return { status: "unknown" };
+  const uid = process.getuid?.();
+  if (uid === void 0 || uid === 0) return { status: "unknown" };
+  const home = process.env.HOME ?? (0, import_node_os15.homedir)();
+  const agents = import_node_path32.default.join(home, "Library", "LaunchAgents");
+  const candidates = [
+    { label: "com.mrrlin.director-bridge", plist: import_node_path32.default.join(agents, "com.mrrlin.director-bridge.plist") },
+    { label: "com.PM2", plist: import_node_path32.default.join(agents, `pm2.${(0, import_node_os15.userInfo)().username}.plist`) }
+  ];
+  for (const candidate of candidates) {
+    const printed = (0, import_node_child_process18.spawnSync)("launchctl", ["print", `gui/${uid}/${candidate.label}`], { encoding: "utf8" });
+    if (printed.status !== 0) continue;
+    if (!(0, import_node_fs18.existsSync)(candidate.plist)) continue;
+    const out = printed.stdout ?? "";
+    const runs = /^\s*runs\s*=\s*(\d+)/m.exec(out);
+    const exitCode = /^\s*last exit code\s*=\s*(-?\d+)/m.exec(out);
+    if (!exitCode || runs?.[1] === "0") return { status: "configured", label: candidate.label };
+    const code = Number(exitCode[1]);
+    return code === 0 ? { status: "configured", label: candidate.label } : { status: "registered_failing", label: candidate.label, lastExitCode: code };
+  }
+  return { status: "not_configured" };
+}
 var HELP_TEXT = `mrrlin-mcp - Mrrlin Phase 1 MCP server CLI
 
 Usage:
@@ -63629,8 +64127,8 @@ async function main() {
         }
       }
       try {
-        const codexHome = process.env.CODEX_HOME ?? import_node_path31.default.join(process.env.HOME ?? (0, import_node_os15.homedir)(), ".codex");
-        (0, import_node_fs17.rmSync)(import_node_path31.default.join(codexHome, "prompts", "report-issue.md"), { force: true });
+        const codexHome = process.env.CODEX_HOME ?? import_node_path32.default.join(process.env.HOME ?? (0, import_node_os15.homedir)(), ".codex");
+        (0, import_node_fs18.rmSync)(import_node_path32.default.join(codexHome, "prompts", "report-issue.md"), { force: true });
       } catch {
       }
       const claudeResult = await installClaude({ binPath, force, serveEnv });
@@ -63691,12 +64189,13 @@ async function main() {
         env: process.env,
         cwd: process.cwd(),
         writeFile: (p, c) => {
-          (0, import_node_fs17.mkdirSync)(import_node_path31.default.dirname(p), { recursive: true, mode: 448 });
-          (0, import_node_fs17.writeFileSync)(p, c, { mode: 384 });
+          (0, import_node_fs18.mkdirSync)(import_node_path32.default.dirname(p), { recursive: true, mode: 448 });
+          (0, import_node_fs18.writeFileSync)(p, c, { mode: 384 });
         },
         runPm2: pm2Runner,
         which: whichBin,
         hasSecret: () => Boolean(readAgentSecret()),
+        bootHookStatus,
         log: (m) => process.stderr.write(`[mrrlin-mcp install-service] ${m}
 `)
       }).ok;
@@ -63709,14 +64208,14 @@ async function main() {
         runPm2: (a) => ({ code: pm2Runner(a).code }),
         removeFile: (p) => {
           try {
-            (0, import_node_fs17.rmSync)(p, { force: true });
+            (0, import_node_fs18.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: purge,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path31.default.join(process.env.HOME ?? (0, import_node_os15.homedir)(), ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path32.default.join(process.env.HOME ?? (0, import_node_os15.homedir)(), ".mrrlin", "ecosystem.config.cjs"),
         log: (m) => process.stderr.write(`[mrrlin-mcp uninstall-service] ${m}
 `)
       });
@@ -63730,14 +64229,14 @@ async function main() {
         runPm2: (a) => ({ code: pm2Runner(a).code }),
         removeFile: (p) => {
           try {
-            (0, import_node_fs17.rmSync)(p, { force: true });
+            (0, import_node_fs18.rmSync)(p, { force: true });
           } catch {
           }
         },
         purgeSecret: true,
         secretPath: agentCredentialPath(),
         tokenPath: operatorTokenPath(),
-        ecoPath: import_node_path31.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
+        ecoPath: import_node_path32.default.join(home, ".mrrlin", "ecosystem.config.cjs"),
         log
       });
       let codexOk = true;
@@ -63757,7 +64256,7 @@ async function main() {
         log(`codex config NOT modified: ${error51 instanceof Error ? error51.message : String(error51)}`);
       }
       try {
-        (0, import_node_fs17.rmSync)(import_node_path31.default.join(home, ".mrrlin"), { recursive: true, force: true });
+        (0, import_node_fs18.rmSync)(import_node_path32.default.join(home, ".mrrlin"), { recursive: true, force: true });
       } catch {
       }
       log("removed ~/.mrrlin");
@@ -63798,7 +64297,7 @@ ${HELP_TEXT}`);
   }
 }
 function resolveSelfBinPath() {
-  return import_node_path30.default.resolve(process.argv[1] ?? process.execPath);
+  return import_node_path31.default.resolve(process.argv[1] ?? process.execPath);
 }
 main().catch((error51) => {
   process.stderr.write(`mrrlin-mcp fatal error: ${error51 instanceof Error ? error51.message : String(error51)}