@qwen-code/qwen-code 0.19.12-preview.0 → 0.20.0-nightly.20260720.0c271659d

package/chunks/{run-qwen-serve-5HWOQFLI.js → run-qwen-serve-GFKSKLF6.js}

@@ -5,6 +5,7 @@ import {
   computeCpuPercent
 } from "./chunk-HGT6JR3U.js";
 import {
+  ACCESS_LOG_CONTROLLER_LOCAL,
   CAPABILITIES_SCHEMA_VERSION,
   ClientMcpSenderRegistry,
   PathMutexRegistry,
@@ -29,7 +30,7 @@ import {
   require_express,
   resolveWebShellDir,
   setDeferredRuntimeRequestTiming
-} from "./chunk-BEZPRKD3.js";
+} from "./chunk-VLDBVLC4.js";
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
@@ -46,7 +47,7 @@ import {
 import "./chunk-WBL3FJEU.js";
 import {
   resolveChannelCwd
-} from "./chunk-E655RDRL.js";
+} from "./chunk-4ODB7WIB.js";
 import {
   loadServeFastPathSettings,
   preResolveServeFastPathHomeEnvOverrides
@@ -55,16 +56,16 @@ import {
   MAX_REGISTERED_WORKSPACES,
   resolveWorkspaceInputs,
   workspaceRegistrationId
-} from "./chunk-EWPLL4OT.js";
+} from "./chunk-6VGRTGOG.js";
 import {
   canonicalizeWorkspace
 } from "./chunk-W7FJ3N32.js";
-import "./chunk-MCYZTKBV.js";
-import "./chunk-BEFQGC6H.js";
+import "./chunk-OLMETXLX.js";
+import "./chunk-NBMIC7DR.js";
 import {
   ChannelWebhookEnqueueError,
   QWEN_SERVER_TOKEN_ENV
-} from "./chunk-HVWPSGDY.js";
+} from "./chunk-Y2ENGUD6.js";
 import {
   channelSelectionNames
 } from "./chunk-TJTKSVIV.js";
@@ -73,7 +74,7 @@ import "./chunk-5HBA2Z7V.js";
 import "./chunk-T2NCM2ET.js";
 import {
   sanitizeLogText
-} from "./chunk-MHEZV3OY.js";
+} from "./chunk-NIJEXGV6.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-GOXKNSDZ.js";
 import {
@@ -83,7 +84,7 @@ import {
 import "./chunk-QRUIS3DN.js";
 import {
   getCliVersion
-} from "./chunk-W4DFAUAO.js";
+} from "./chunk-SQMTULHJ.js";
 import "./chunk-VJNBRRZG.js";
 import "./chunk-ALGGS7UH.js";
 import {
@@ -96,7 +97,9 @@ import {
 import "./chunk-5M6IDOMF.js";
 import "./chunk-T4TZQJ7W.js";
 import "./chunk-H6XPXXMH.js";
-import "./chunk-E2UVIFI2.js";
+import {
+  require_proper_lockfile
+} from "./chunk-E2UVIFI2.js";
 import "./chunk-CR3C7WXL.js";
 import "./chunk-XWRJCPHC.js";
 import {
@@ -122,7 +125,7 @@ import * as fs from "node:fs";
 import * as https from "node:https";
 import * as path from "node:path";
 import * as os from "node:os";
-import { monitorEventLoopDelay, performance } from "node:perf_hooks";
+import { monitorEventLoopDelay, performance as performance2 } from "node:perf_hooks";
 
 // packages/cli/src/serve/permission-audit.ts
 init_esbuild_shims();
@@ -243,9 +246,11 @@ __name(createPermissionAuditPublisher, "createPermissionAuditPublisher");
 
 // packages/cli/src/serve/daemon-logger.ts
 init_esbuild_shims();
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 import * as nodeFs from "node:fs";
 import * as nodePath from "node:path";
 import * as crypto from "node:crypto";
+import { performance } from "node:perf_hooks";
 var FIXED_CTX_ORDER = [
   "route",
   "sessionId",
@@ -254,6 +259,31 @@ var FIXED_CTX_ORDER = [
   "channelId"
 ];
 var FIXED_CTX_SET = new Set(FIXED_CTX_ORDER);
+var ISSUE_ORDER = [
+  "init_failed",
+  "rotation_failed",
+  "retention_failed",
+  "queue_overflow",
+  "write_failed",
+  "lease_compromised"
+];
+var DEFAULT_POLICY = {
+  maxBytes: 10 * 1024 * 1024,
+  maxArchives: 4,
+  maxRecordBytes: 256 * 1024,
+  maxPendingBytes: 4 * 1024 * 1024,
+  stableAcquireBudgetMs: 1e3,
+  maintenanceAcquireBudgetMs: 250,
+  lockStaleMs: 6e4,
+  lockUpdateMs: 1e4,
+  rotationRetryIntervalMs: 6e4,
+  closeDrainBudgetMs: 2e3
+};
+var ARCHIVE_RE = /^daemon-(\d{12})-(\d{8}T\d{9}Z)-([0-9a-f]{8})\.log$/;
+var FALLBACK_DIR_RE = /^run-[0-9a-f]{32}$/;
+var ARCHIVE_NAME_ATTEMPTS = 3;
+var FILE_MODE = 384;
+var DIRECTORY_MODE = 448;
 function renderCtxValue(value) {
   const s = String(value);
   return /[\s=]/.test(s) ? JSON.stringify(s) : s;
@@ -269,7 +299,7 @@ function renderCtx(ctx) {
     }
   }
   const extraKeys = Object.keys(ctx).filter(
-    (k) => !FIXED_CTX_SET.has(k) && ctx[k] !== void 0 && ctx[k] !== null
+    (key) => !FIXED_CTX_SET.has(key) && ctx[key] !== void 0 && ctx[key] !== null
   ).sort();
   for (const key of extraKeys) {
     parts.push(`${key}=${renderCtxValue(ctx[key])}`);
@@ -280,7 +310,7 @@ __name(renderCtx, "renderCtx");
 function renderErr(err) {
   if (!err) return "";
   const body = err.stack ?? `${err.name ?? "Error"}: ${err.message}`;
-  return body.split("\n").map((l) => `  ${l}`).join("\n") + "\n";
+  return body.split("\n").map((line) => `  ${line}`).join("\n") + "\n";
 }
 __name(renderErr, "renderErr");
 function buildDaemonLogLine(args) {
@@ -290,19 +320,17 @@ function buildDaemonLogLine(args) {
 ${renderErr(args.err)}`;
 }
 __name(buildDaemonLogLine, "buildDaemonLogLine");
-var NOOP_LOGGER = {
-  info: /* @__PURE__ */ __name(() => {
-  }, "info"),
-  warn: /* @__PURE__ */ __name(() => {
-  }, "warn"),
-  error: /* @__PURE__ */ __name(() => {
-  }, "error"),
-  raw: /* @__PURE__ */ __name(() => {
-  }, "raw"),
-  getLogPath: /* @__PURE__ */ __name(() => "", "getLogPath"),
-  getDaemonId: /* @__PURE__ */ __name(() => "", "getDaemonId"),
-  flush: /* @__PURE__ */ __name(() => Promise.resolve(), "flush")
-};
+function buildDaemonFileLogLine(args, runId, pid) {
+  const callerCtx = args.ctx ? Object.fromEntries(
+    Object.entries(args.ctx).filter(
+      ([key]) => key !== "runId" && key !== "pid"
+    )
+  ) : void 0;
+  const ctxStr = renderCtx(callerCtx);
+  return `${args.now.toISOString()} [${args.level}] [DAEMON] runId=${runId} pid=${pid} ${ctxStr}${args.message}
+${renderErr(args.err)}`;
+}
+__name(buildDaemonFileLogLine, "buildDaemonFileLogLine");
 function getRuntimeBaseDir(runtimeOutputDir, cwd) {
   const envDir = process.env["QWEN_RUNTIME_DIR"];
   if (envDir) return resolveConfigPathLite(envDir);
@@ -314,19 +342,6 @@ function resolveDaemonLogBaseDir(runtimeOutputDir, cwd) {
   return nodePath.join(getRuntimeBaseDir(runtimeOutputDir, cwd), "debug");
 }
 __name(resolveDaemonLogBaseDir, "resolveDaemonLogBaseDir");
-async function updateSymlinkBestEffort(linkPath, targetPath) {
-  const linkDir = nodePath.dirname(linkPath);
-  const relativeTarget = nodePath.relative(linkDir, targetPath);
-  try {
-    await nodeFs.promises.unlink(linkPath);
-  } catch {
-  }
-  try {
-    await nodeFs.promises.symlink(relativeTarget, linkPath);
-  } catch {
-  }
-}
-__name(updateSymlinkBestEffort, "updateSymlinkBestEffort");
 function isOptedOut() {
   const raw = process.env["QWEN_DAEMON_LOG_FILE"];
   if (!raw) return false;
@@ -341,73 +356,1252 @@ function computeDaemonId(pid) {
   return `daemon:${pid}`;
 }
 __name(computeDaemonId, "computeDaemonId");
-function computeDaemonLogFileName(pid) {
-  return `serve-${pid}.log`;
+function isErrno(error, code) {
+  return error instanceof Error && "code" in error && error.code === code;
 }
-__name(computeDaemonLogFileName, "computeDaemonLogFileName");
-function initDaemonLogger(opts) {
-  if (isOptedOut()) return NOOP_LOGGER;
-  const pid = opts.pid ?? process.pid;
-  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
-  const stderr = opts.stderr ?? writeStderrLine;
-  const baseDir = opts.baseDir ?? resolveDaemonLogBaseDir();
-  const daemonId = computeDaemonId(pid);
-  const workspaceHash = computeWorkspaceHash(opts.boundWorkspace);
-  const daemonDir = nodePath.join(baseDir, "daemon");
-  const logPath = nodePath.join(daemonDir, computeDaemonLogFileName(pid));
+__name(isErrno, "isErrno");
+function resolvePolicy(overrides) {
+  const policy = { ...DEFAULT_POLICY, ...overrides };
+  for (const [name, value] of Object.entries(policy)) {
+    if (!Number.isFinite(value) || value < 0) {
+      throw new TypeError(`Invalid daemon logger policy ${name}=${value}`);
+    }
+  }
+  if (policy.maxBytes === 0 || policy.maxArchives === 0 || policy.maxRecordBytes === 0 || policy.maxPendingBytes === 0) {
+    throw new TypeError(
+      "Daemon logger size/count policy values must be positive"
+    );
+  }
+  if (policy.maxRecordBytes > policy.maxBytes) {
+    throw new TypeError(
+      "Daemon logger maxRecordBytes must not exceed maxBytes"
+    );
+  }
+  if (policy.maxRecordBytes > policy.maxPendingBytes) {
+    throw new TypeError(
+      "Daemon logger maxRecordBytes must not exceed maxPendingBytes"
+    );
+  }
+  return policy;
+}
+__name(resolvePolicy, "resolvePolicy");
+function statusSnapshot(runId, mode, issues, droppedRecords, droppedBytes) {
+  return {
+    runId,
+    mode,
+    health: issues.size === 0 ? "ok" : "degraded",
+    issues: ISSUE_ORDER.filter((issue) => issues.has(issue)),
+    droppedRecords,
+    droppedBytes
+  };
+}
+__name(statusSnapshot, "statusSnapshot");
+function createStderrOnlyLogger(input) {
+  const tee = /* @__PURE__ */ __name((level, message, ctx, err) => {
+    input.stderr(
+      buildDaemonLogLine({
+        level,
+        message,
+        now: input.now(),
+        ctx,
+        err
+      }).trimEnd()
+    );
+  }, "tee");
+  return {
+    info: /* @__PURE__ */ __name((message, ctx) => tee("INFO", message, ctx), "info"),
+    warn: /* @__PURE__ */ __name((message, ctx) => tee("WARN", message, ctx), "warn"),
+    error: /* @__PURE__ */ __name((message, err, ctx) => tee("ERROR", message, ctx, err ?? void 0), "error"),
+    raw: /* @__PURE__ */ __name(() => {
+    }, "raw"),
+    getLogPath: /* @__PURE__ */ __name(() => "", "getLogPath"),
+    getDaemonId: /* @__PURE__ */ __name(() => input.daemonId, "getDaemonId"),
+    getStatus: /* @__PURE__ */ __name(() => statusSnapshot(input.runId, "stderr-only", input.issues, 0, 0), "getStatus"),
+    flush: /* @__PURE__ */ __name(() => Promise.resolve(), "flush"),
+    close: /* @__PURE__ */ __name(() => Promise.resolve(), "close")
+  };
+}
+__name(createStderrOnlyLogger, "createStderrOnlyLogger");
+function capUtf8Record(record, maxBytes) {
+  const bytes = Buffer.from(record, "utf8");
+  if (bytes.length <= maxBytes) return record;
+  const marker = `
+[truncated originalBytes=${bytes.length}]
+`;
+  const markerBytes = Buffer.from(marker, "utf8");
+  if (markerBytes.length >= maxBytes) {
+    return Buffer.from("[truncated]\n", "utf8").subarray(0, maxBytes).toString("utf8");
+  }
+  let prefixBytes = maxBytes - markerBytes.length;
+  while (prefixBytes > 0 && (bytes[prefixBytes] & 192) === 128) {
+    prefixBytes -= 1;
+  }
+  return bytes.subarray(0, prefixBytes).toString("utf8") + marker;
+}
+__name(capUtf8Record, "capUtf8Record");
+async function ensureRealDirectory(fs2, dirPath, mutationAllowed = () => true) {
+  try {
+    const existing = await fs2.lstat(dirPath);
+    if (!existing.isDirectory() || existing.isSymbolicLink()) {
+      throw new Error(`${dirPath} is not a real directory`);
+    }
+    return;
+  } catch (error) {
+    if (!isErrno(error, "ENOENT")) throw error;
+  }
+  if (!mutationAllowed()) {
+    throw new Error(`File mutation is no longer allowed for ${dirPath}`);
+  }
+  await fs2.mkdir(dirPath, { recursive: true, mode: DIRECTORY_MODE });
+  const created = await fs2.lstat(dirPath);
+  if (!created.isDirectory() || created.isSymbolicLink()) {
+    throw new Error(`${dirPath} is not a real directory`);
+  }
+}
+__name(ensureRealDirectory, "ensureRealDirectory");
+async function activeFileSize(fs2, activePath) {
   try {
-    nodeFs.mkdirSync(daemonDir, { recursive: true });
-    const firstLine = buildDaemonLogLine({
-      level: "INFO",
-      message: `daemon started pid=${pid}`,
-      now: now(),
-      ctx: { workspace: opts.boundWorkspace, workspaceHash }
+    const stat = await fs2.lstat(activePath);
+    if (!stat.isFile() || stat.isSymbolicLink()) {
+      throw new Error(`${activePath} is not a regular file`);
+    }
+    return stat.size;
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return 0;
+    throw error;
+  }
+}
+__name(activeFileSize, "activeFileSize");
+async function lastByteIsNewline(fs2, activePath, size) {
+  if (size === 0) return true;
+  const handle = await fs2.open(activePath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(1);
+    const result = await handle.read(buffer, 0, 1, size - 1);
+    return result.bytesRead === 1 && buffer[0] === 10;
+  } finally {
+    await handle.close();
+  }
+}
+__name(lastByteIsNewline, "lastByteIsNewline");
+function archiveTimestamp(now) {
+  return now.toISOString().replace(/[-:.]/g, "");
+}
+__name(archiveTimestamp, "archiveTimestamp");
+async function scanArchives(fs2, archiveDir) {
+  const entries = await fs2.readdir(archiveDir, { withFileTypes: true });
+  const archives = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    const match = ARCHIVE_RE.exec(entry.name);
+    if (!match) continue;
+    archives.push({ name: entry.name, generation: Number(match[1]) });
+  }
+  archives.sort(
+    (a, b) => a.generation - b.generation || a.name.localeCompare(b.name)
+  );
+  return archives;
+}
+__name(scanArchives, "scanArchives");
+function lockRetries(maxRetryTime) {
+  if (maxRetryTime <= 0) return 0;
+  return {
+    retries: 4,
+    factor: 2,
+    minTimeout: 50,
+    maxTimeout: 400,
+    randomize: true,
+    maxRetryTime
+  };
+}
+__name(lockRetries, "lockRetries");
+async function acquireLease(input) {
+  const lease = {
+    compromised: false,
+    released: false,
+    release: /* @__PURE__ */ __name(async () => {
+    }, "release")
+  };
+  const release = await input.acquireLock(input.targetPath, {
+    lockfilePath: input.lockPath,
+    realpath: true,
+    stale: input.policy.lockStaleMs,
+    update: input.policy.lockUpdateMs,
+    retries: lockRetries(input.retryBudgetMs),
+    onCompromised: /* @__PURE__ */ __name((error) => {
+      if (lease.released) return;
+      lease.compromised = true;
+      try {
+        input.onCompromised?.(error);
+      } catch {
+      }
+    }, "onCompromised")
+  });
+  try {
+    if (lease.compromised) {
+      throw new Error(
+        `Lease was compromised while acquiring ${input.lockPath}`
+      );
+    }
+    await input.fs.chmod(input.lockPath, DIRECTORY_MODE);
+  } catch (error) {
+    lease.released = true;
+    await release().catch(() => {
     });
-    nodeFs.appendFileSync(logPath, firstLine);
-  } catch (err) {
-    stderr(
-      `qwen serve: daemon log disabled \u2014 init failed: ${err instanceof Error ? err.message : String(err)}`
+    throw error;
+  }
+  lease.release = async () => {
+    if (lease.released) return;
+    lease.released = true;
+    await release();
+  };
+  return lease;
+}
+__name(acquireLease, "acquireLease");
+async function updateLatestBestEffort(fs2, daemonDir, targetPath, mutationAllowed) {
+  const linkPath = nodePath.join(daemonDir, "latest");
+  if (!mutationAllowed()) return;
+  try {
+    await fs2.unlink(linkPath);
+  } catch {
+  }
+  if (!mutationAllowed()) return;
+  try {
+    await fs2.symlink(nodePath.relative(daemonDir, targetPath), linkPath);
+  } catch {
+  }
+}
+__name(updateLatestBestEffort, "updateLatestBestEffort");
+async function readRecentFallback(fs2, runsDir) {
+  try {
+    const raw = await fs2.readFile(
+      nodePath.join(runsDir, "recent-fallback"),
+      "utf8"
     );
-    return NOOP_LOGGER;
+    const name = raw.trim();
+    return FALLBACK_DIR_RE.test(name) ? name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(readRecentFallback, "readRecentFallback");
+async function writeRecentFallback(fs2, runsDir, name, mutationAllowed = () => true) {
+  const locatorPath = nodePath.join(runsDir, "recent-fallback");
+  if (!name) {
+    if (!mutationAllowed()) {
+      throw new Error("Fallback locator mutation is no longer allowed");
+    }
+    try {
+      await fs2.unlink(locatorPath);
+    } catch (error) {
+      if (!isErrno(error, "ENOENT")) throw error;
+    }
+    return;
+  }
+  if (!FALLBACK_DIR_RE.test(name)) {
+    throw new Error(`Invalid fallback locator target: ${name}`);
   }
+  const tempPath = nodePath.join(runsDir, ".recent-fallback.tmp");
   try {
-    const aliasPath = nodePath.join(daemonDir, "latest");
-    void updateSymlinkBestEffort(aliasPath, logPath);
+    const tempStat = await fs2.lstat(tempPath);
+    if (!tempStat.isFile() || tempStat.isSymbolicLink()) {
+      throw new Error(`${tempPath} is not a regular file`);
+    }
+    if (!mutationAllowed()) {
+      throw new Error("Fallback locator mutation is no longer allowed");
+    }
+    await fs2.unlink(tempPath);
+  } catch (error) {
+    if (!isErrno(error, "ENOENT")) throw error;
+  }
+  if (!mutationAllowed()) {
+    throw new Error("Fallback locator mutation is no longer allowed");
+  }
+  await fs2.writeFile(tempPath, `${name}
+`, {
+    encoding: "utf8",
+    mode: FILE_MODE,
+    flag: "wx"
+  });
+  if (!mutationAllowed()) {
+    throw new Error("Fallback locator mutation is no longer allowed");
+  }
+  await fs2.rename(tempPath, locatorPath);
+}
+__name(writeRecentFallback, "writeRecentFallback");
+async function listFallbackDirectories(fs2, runsDir) {
+  const entries = await fs2.readdir(runsDir, { withFileTypes: true });
+  return entries.filter((entry) => entry.isDirectory() && FALLBACK_DIR_RE.test(entry.name)).map((entry) => entry.name).sort();
+}
+__name(listFallbackDirectories, "listFallbackDirectories");
+async function fallbackActivityMtime(fs2, familyDir) {
+  try {
+    return (await fs2.lstat(nodePath.join(familyDir, "daemon.log"))).mtimeMs;
+  } catch (error) {
+    if (!isErrno(error, "ENOENT")) throw error;
+    return (await fs2.lstat(familyDir)).mtimeMs;
+  }
+}
+__name(fallbackActivityMtime, "fallbackActivityMtime");
+async function cleanupFallbackFamilies(input) {
+  const mutationAllowed = input.mutationAllowed ?? (() => true);
+  const locator = await readRecentFallback(input.fs, input.runsDir);
+  const names = await listFallbackDirectories(input.fs, input.runsDir);
+  const live = /* @__PURE__ */ new Set();
+  const inactive = [];
+  try {
+    for (const name of names) {
+      if (!mutationAllowed()) {
+        throw new Error("Fallback cleanup lease was compromised");
+      }
+      const familyDir = nodePath.join(input.runsDir, name);
+      let lease;
+      try {
+        lease = await acquireLease({
+          fs: input.fs,
+          acquireLock: input.acquireLock,
+          targetPath: familyDir,
+          lockPath: nodePath.join(familyDir, ".owner.lock"),
+          policy: input.policy,
+          retryBudgetMs: 0
+        });
+        if (!mutationAllowed()) {
+          throw new Error("Fallback cleanup lease was compromised");
+        }
+        if (lease.compromised) {
+          await lease.release().catch(() => {
+          });
+          throw new Error(`Fallback owner lease was compromised: ${familyDir}`);
+        }
+        inactive.push({
+          name,
+          mtimeMs: await fallbackActivityMtime(input.fs, familyDir),
+          lease
+        });
+      } catch (error) {
+        await lease?.release().catch(() => {
+        });
+        if (isErrno(error, "ELOCKED")) {
+          live.add(name);
+          continue;
+        }
+        throw error;
+      }
+    }
+    const inactiveNames = new Set(inactive.map((entry) => entry.name));
+    const retainedInactive = (input.preferredInactive && inactiveNames.has(input.preferredInactive) ? input.preferredInactive : void 0) ?? (locator && inactiveNames.has(locator) ? locator : void 0) ?? inactive.slice().sort(
+      (a, b) => b.mtimeMs - a.mtimeMs || b.name.localeCompare(a.name)
+    )[0]?.name;
+    for (const entry of inactive) {
+      await entry.lease.release();
+      if (entry.name === retainedInactive) continue;
+      if (!mutationAllowed()) {
+        throw new Error("Fallback cleanup lease was compromised");
+      }
+      await input.fs.rm(nodePath.join(input.runsDir, entry.name), {
+        recursive: true,
+        force: true
+      });
+    }
+    const remaining = [...live, ...retainedInactive ? [retainedInactive] : []].filter((name, index, all) => all.indexOf(name) === index).sort();
+    const nextLocator = retainedInactive ?? (locator && remaining.includes(locator) ? locator : remaining.at(-1));
+    if (locator !== nextLocator) {
+      await writeRecentFallback(
+        input.fs,
+        input.runsDir,
+        nextLocator,
+        mutationAllowed
+      ).catch(() => {
+      });
+    }
+  } finally {
+    await Promise.all(
+      inactive.filter((entry) => !entry.lease.released).map((entry) => entry.lease.release().catch(() => {
+      }))
+    );
+  }
+}
+__name(cleanupFallbackFamilies, "cleanupFallbackFamilies");
+async function acquireMaintenanceLease(input) {
+  await ensureRealDirectory(input.fs, input.runsDir);
+  return acquireLease({
+    fs: input.fs,
+    acquireLock: input.acquireLock,
+    targetPath: input.runsDir,
+    lockPath: nodePath.join(input.runsDir, ".maintenance.lock"),
+    policy: input.policy,
+    retryBudgetMs: input.retryBudgetMs
+  });
+}
+__name(acquireMaintenanceLease, "acquireMaintenanceLease");
+async function allocateFallbackFamily(input) {
+  const runsDir = nodePath.join(input.daemonDir, "runs");
+  const maintenance = await acquireMaintenanceLease({
+    ...input,
+    runsDir,
+    retryBudgetMs: input.policy.maintenanceAcquireBudgetMs
+  });
+  let familyDir;
+  let familyCreated = false;
+  let lease;
+  const maintenanceAllowsMutation = /* @__PURE__ */ __name(() => !maintenance.compromised && !maintenance.released, "maintenanceAllowsMutation");
+  try {
+    if (!maintenanceAllowsMutation()) {
+      throw new Error("Fallback maintenance lease was compromised");
+    }
+    await cleanupFallbackFamilies({
+      ...input,
+      runsDir,
+      mutationAllowed: maintenanceAllowsMutation
+    });
+    if (!maintenanceAllowsMutation()) {
+      throw new Error("Fallback maintenance lease was compromised");
+    }
+    const name = `run-${input.runId}`;
+    familyDir = nodePath.join(runsDir, name);
+    await input.fs.mkdir(familyDir, { mode: DIRECTORY_MODE });
+    familyCreated = true;
+    if (!maintenanceAllowsMutation()) {
+      throw new Error("Fallback maintenance lease was compromised");
+    }
+    lease = await acquireLease({
+      fs: input.fs,
+      acquireLock: input.acquireLock,
+      targetPath: familyDir,
+      lockPath: nodePath.join(familyDir, ".owner.lock"),
+      policy: input.policy,
+      retryBudgetMs: 0,
+      onCompromised: input.onCompromised
+    });
+    if (!maintenanceAllowsMutation()) {
+      throw new Error("Fallback maintenance lease was compromised");
+    }
+  } catch (error) {
+    await lease?.release().catch(() => {
+    });
+    if (familyCreated && familyDir && maintenanceAllowsMutation()) {
+      await input.fs.rm(familyDir, { recursive: true, force: true }).catch(() => {
+      });
+    }
+    await maintenance.release().catch(() => {
+    });
+    throw error;
+  }
+  try {
+    await maintenance.release();
+  } catch (error) {
+    await lease.release().catch(() => {
+    });
+    throw error;
+  }
+  return {
+    mode: "fallback",
+    activePath: nodePath.join(familyDir, "daemon.log"),
+    archiveDir: nodePath.join(familyDir, "archive"),
+    familyDir,
+    lease,
+    releaseLease: lease.release
+  };
+}
+__name(allocateFallbackFamily, "allocateFallbackFamily");
+async function removeFailedFallbackBestEffort(input) {
+  if (input.family.lease.compromised) {
+    await input.family.releaseLease().catch(() => {
+    });
+    return;
+  }
+  const runsDir = nodePath.dirname(input.family.familyDir);
+  let maintenance;
+  try {
+    maintenance = await acquireMaintenanceLease({
+      ...input,
+      runsDir,
+      retryBudgetMs: 0
+    });
   } catch {
+    await input.family.releaseLease().catch(() => {
+    });
+    return;
+  }
+  try {
+    if (maintenance.compromised) {
+      await input.family.releaseLease().catch(() => {
+      });
+      return;
+    }
+    try {
+      await input.family.releaseLease();
+    } catch {
+      return;
+    }
+    if (maintenance.compromised || input.family.lease.compromised) return;
+    await input.fs.rm(input.family.familyDir, { recursive: true, force: true }).catch(() => {
+    });
+  } finally {
+    await maintenance.release().catch(() => {
+    });
+  }
+}
+__name(removeFailedFallbackBestEffort, "removeFailedFallbackBestEffort");
+async function closeFallbackFamily(input) {
+  if (input.family.lease.compromised) {
+    await input.family.releaseLease().catch(() => {
+    });
+    return;
+  }
+  const runsDir = nodePath.dirname(input.family.familyDir);
+  let maintenance;
+  try {
+    maintenance = await acquireMaintenanceLease({
+      ...input,
+      runsDir,
+      retryBudgetMs: 0
+    });
+  } catch {
+    await input.family.releaseLease().catch(input.onRetentionError);
+    return;
   }
+  try {
+    if (maintenance.compromised) {
+      throw new Error("Fallback maintenance lease was compromised");
+    }
+    await input.family.releaseLease();
+    const name = nodePath.basename(input.family.familyDir);
+    const mutationAllowed = /* @__PURE__ */ __name(() => !maintenance.compromised && !input.family.lease.compromised, "mutationAllowed");
+    await cleanupFallbackFamilies({
+      ...input,
+      runsDir,
+      preferredInactive: name,
+      mutationAllowed
+    });
+    await writeRecentFallback(input.fs, runsDir, name, mutationAllowed);
+  } catch (error) {
+    await input.family.releaseLease().catch(input.onRetentionError);
+    input.onRetentionError(error);
+  } finally {
+    await maintenance.release().catch(input.onRetentionError);
+  }
+}
+__name(closeFallbackFamily, "closeFallbackFamily");
+async function cleanupFallbacksBestEffort(input) {
+  const runsDir = nodePath.join(input.daemonDir, "runs");
+  try {
+    const stat = await input.fs.lstat(runsDir);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+      throw new Error(`${runsDir} is not a real directory`);
+    }
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) return;
+    input.onRetentionError(error);
+    return;
+  }
+  let maintenance;
+  try {
+    const currentMaintenance = await acquireMaintenanceLease({
+      ...input,
+      runsDir,
+      retryBudgetMs: 0
+    });
+    maintenance = currentMaintenance;
+    const mutationAllowed = /* @__PURE__ */ __name(() => !currentMaintenance.compromised && !currentMaintenance.released && (input.mutationAllowed?.() ?? true), "mutationAllowed");
+    if (!mutationAllowed()) {
+      throw new Error("Fallback maintenance lease was compromised");
+    }
+    await cleanupFallbackFamilies({
+      ...input,
+      runsDir,
+      mutationAllowed
+    });
+  } catch (error) {
+    if (!isErrno(error, "ELOCKED")) input.onRetentionError(error);
+  } finally {
+    await maintenance?.release().catch(input.onRetentionError);
+  }
+}
+__name(cleanupFallbacksBestEffort, "cleanupFallbacksBestEffort");
+function createConcreteLogger(input) {
   let pending = Promise.resolve();
-  let degraded = false;
-  const enqueueAppend = /* @__PURE__ */ __name((line) => {
-    pending = pending.then(
-      () => nodeFs.promises.appendFile(logPath, line).catch((err) => {
-        if (!degraded) {
-          degraded = true;
-          stderr(
-            `qwen serve: daemon log write failed \u2014 entering degraded mode: ${err instanceof Error ? err.message : String(err)}`
-          );
+  let pendingBytes = 0;
+  let droppedRecords = 0;
+  let droppedBytes = 0;
+  let reportedDroppedRecords = 0;
+  let reportedDroppedBytes = 0;
+  let overflowEpisode = false;
+  let dropSummaryPending = false;
+  let acceptingFileRecords = true;
+  let closePromise;
+  const markDropped = /* @__PURE__ */ __name((bytes, queueOverflow = false) => {
+    droppedRecords += 1;
+    droppedBytes += bytes;
+    if (queueOverflow) {
+      input.issues.add("queue_overflow");
+      if (!overflowEpisode) {
+        overflowEpisode = true;
+        input.stderr(
+          "qwen serve: daemon log queue limit reached; dropping file copies until capacity recovers"
+        );
+      }
+    }
+  }, "markDropped");
+  const markRotationFailure = /* @__PURE__ */ __name((message, error) => {
+    input.issues.add("rotation_failed");
+    input.state.nextRotationRetryAt = input.monotonicNow() + input.policy.rotationRetryIntervalMs;
+    input.warnOnce(
+      `rotation:${message}`,
+      `qwen serve: daemon log rotation failed; ${message}${error ? `: ${error instanceof Error ? error.message : String(error)}` : ""}`
+    );
+  }, "markRotationFailure");
+  const markRetentionFailure = /* @__PURE__ */ __name((error) => {
+    input.issues.add("retention_failed");
+    input.warnOnce(
+      "retention",
+      `qwen serve: daemon log retention cleanup failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }, "markRetentionFailure");
+  const fileMutationAllowed = /* @__PURE__ */ __name(() => !input.state.poisoned && !input.family.lease.compromised && !input.family.lease.released, "fileMutationAllowed");
+  const prepareArchives = /* @__PURE__ */ __name(async () => {
+    if (!input.state.archiveAvailable && input.monotonicNow() < input.state.nextRotationRetryAt) {
+      return false;
+    }
+    try {
+      await ensureRealDirectory(
+        input.fs,
+        input.family.archiveDir,
+        fileMutationAllowed
+      );
+      if (!fileMutationAllowed()) return false;
+      input.state.archives = await scanArchives(
+        input.fs,
+        input.family.archiveDir
+      );
+      input.state.nextArchiveGeneration = (input.state.archives.at(-1)?.generation ?? 0) + 1;
+      input.state.archiveAvailable = true;
+      input.state.nextRotationRetryAt = 0;
+      return true;
+    } catch (error) {
+      if (!fileMutationAllowed()) return false;
+      input.state.archiveAvailable = false;
+      markRotationFailure("continuing without file rotation", error);
+      return false;
+    }
+  }, "prepareArchives");
+  const pruneForRotation = /* @__PURE__ */ __name(async () => {
+    while (input.state.archives.length >= input.policy.maxArchives) {
+      if (!fileMutationAllowed()) return false;
+      const oldest = input.state.archives[0];
+      try {
+        await input.fs.unlink(
+          nodePath.join(input.family.archiveDir, oldest.name)
+        );
+        input.state.archives.shift();
+      } catch (error) {
+        if (isErrno(error, "ENOENT")) {
+          input.state.archives.shift();
+          continue;
         }
-      })
+        markRetentionFailure(error);
+        input.state.nextRotationRetryAt = input.monotonicNow() + input.policy.rotationRetryIntervalMs;
+        return false;
+      }
+    }
+    return true;
+  }, "pruneForRotation");
+  const archivePath = /* @__PURE__ */ __name(async () => {
+    const generation = input.state.nextArchiveGeneration;
+    if (generation > 999999999999) {
+      markRotationFailure("archive generation limit reached");
+      return void 0;
+    }
+    for (let attempt = 0; attempt < ARCHIVE_NAME_ATTEMPTS; attempt += 1) {
+      let name;
+      try {
+        name = `daemon-${String(generation).padStart(12, "0")}-${archiveTimestamp(input.now())}-${crypto.randomBytes(4).toString("hex")}.log`;
+      } catch (error) {
+        markRotationFailure("archive filename generation failed", error);
+        return void 0;
+      }
+      const candidate = nodePath.join(input.family.archiveDir, name);
+      try {
+        await input.fs.lstat(candidate);
+      } catch (error) {
+        if (isErrno(error, "ENOENT")) return { name, generation };
+        markRotationFailure("archive target validation failed", error);
+        return void 0;
+      }
+    }
+    markRotationFailure("archive filename collision limit reached");
+    return void 0;
+  }, "archivePath");
+  const appendActive = /* @__PURE__ */ __name(async (record, forceRotation = false) => {
+    if (!fileMutationAllowed()) return "dropped";
+    const bytes = Buffer.byteLength(record, "utf8");
+    const needsRotation = input.state.currentBytes > 0 && (forceRotation || input.state.currentBytes + bytes > input.policy.maxBytes);
+    if (needsRotation) {
+      if (input.monotonicNow() < input.state.nextRotationRetryAt) {
+        return "dropped";
+      }
+      if (!await prepareArchives()) return "dropped";
+      if (!fileMutationAllowed()) return "dropped";
+      if (!await pruneForRotation()) return "dropped";
+      const archive = await archivePath();
+      if (!archive) return "dropped";
+      if (!fileMutationAllowed()) return "dropped";
+      try {
+        await input.fs.rename(
+          input.family.activePath,
+          nodePath.join(input.family.archiveDir, archive.name)
+        );
+      } catch (error) {
+        markRotationFailure("active file rename failed", error);
+        return "dropped";
+      }
+      input.state.archives.push(archive);
+      input.state.archives.sort(
+        (a, b) => a.generation - b.generation || a.name.localeCompare(b.name)
+      );
+      input.state.nextArchiveGeneration = archive.generation + 1;
+      input.state.currentBytes = 0;
+      if (!fileMutationAllowed()) return "dropped";
+    }
+    if (!fileMutationAllowed()) return "dropped";
+    try {
+      if (input.state.exclusiveBootCreate) {
+        await input.fs.writeFile(input.family.activePath, record, {
+          encoding: "utf8",
+          mode: FILE_MODE,
+          flag: "wx"
+        });
+        input.state.exclusiveBootCreate = false;
+      } else {
+        await input.fs.appendFile(input.family.activePath, record, {
+          encoding: "utf8",
+          mode: FILE_MODE,
+          flag: "a"
+        });
+      }
+      input.state.currentBytes += bytes;
+      return "written";
+    } catch (error) {
+      input.state.poisoned = true;
+      input.issues.add("write_failed");
+      input.warnOnce(
+        "write-failed",
+        `qwen serve: daemon log write failed; file logging disabled for this run: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return "unknown";
+    }
+  }, "appendActive");
+  const unreportedDropRecord = /* @__PURE__ */ __name(() => {
+    const records = droppedRecords - reportedDroppedRecords;
+    const bytes = droppedBytes - reportedDroppedBytes;
+    if (records <= 0) return void 0;
+    return capUtf8Record(
+      buildDaemonFileLogLine(
+        {
+          level: "WARN",
+          message: "daemon file log records dropped",
+          now: input.now(),
+          ctx: { droppedRecords: records, droppedBytes: bytes }
+        },
+        input.runId,
+        input.pid
+      ),
+      input.policy.maxRecordBytes
     );
-  }, "enqueueAppend");
-  const teeLine = /* @__PURE__ */ __name((level, message, ctx, err) => {
-    const line = buildDaemonLogLine({ level, message, now: now(), ctx, err });
-    stderr(line.trimEnd());
-    enqueueAppend(line);
-  }, "teeLine");
-  return {
-    info: /* @__PURE__ */ __name((message, ctx) => teeLine("INFO", message, ctx), "info"),
-    warn: /* @__PURE__ */ __name((message, ctx) => teeLine("WARN", message, ctx), "warn"),
-    error: /* @__PURE__ */ __name((message, err, ctx) => teeLine("ERROR", message, ctx, err ?? void 0), "error"),
+  }, "unreportedDropRecord");
+  const enqueueRecord = /* @__PURE__ */ __name((record, callerOriginated, onSettled) => {
+    const bytes = Buffer.byteLength(record, "utf8");
+    if (pendingBytes + bytes > input.policy.maxPendingBytes) {
+      if (callerOriginated) markDropped(bytes, true);
+      return false;
+    }
+    pendingBytes += bytes;
+    pending = pending.then(async () => {
+      let outcome = "unknown";
+      try {
+        outcome = await appendActive(record);
+        if (callerOriginated && outcome === "dropped") markDropped(bytes);
+      } catch (error) {
+        input.state.poisoned = true;
+        input.issues.add("write_failed");
+        input.warnOnce(
+          "queue-failed",
+          `qwen serve: daemon log queue failed; file logging disabled for this run: ${error instanceof Error ? error.message : String(error)}`
+        );
+      } finally {
+        onSettled?.(outcome);
+      }
+    }).catch(() => {
+    }).finally(() => {
+      pendingBytes -= bytes;
+    });
+    return true;
+  }, "enqueueRecord");
+  const enqueueDropSummary = /* @__PURE__ */ __name(() => {
+    if (dropSummaryPending) return;
+    const summary = unreportedDropRecord();
+    if (!summary) return;
+    const summaryRecords = droppedRecords;
+    const summaryBytes = droppedBytes;
+    if (enqueueRecord(summary, false, (outcome) => {
+      if (outcome === "written") {
+        reportedDroppedRecords = summaryRecords;
+        reportedDroppedBytes = summaryBytes;
+      }
+      dropSummaryPending = false;
+    })) {
+      dropSummaryPending = true;
+      overflowEpisode = false;
+    }
+  }, "enqueueDropSummary");
+  const submitFileRecord = /* @__PURE__ */ __name((record) => {
+    if (!acceptingFileRecords) return;
+    const bytes = Buffer.byteLength(record, "utf8");
+    if (!fileMutationAllowed()) {
+      markDropped(bytes);
+      return;
+    }
+    enqueueDropSummary();
+    enqueueRecord(record, true);
+  }, "submitFileRecord");
+  const tee = /* @__PURE__ */ __name((level, message, ctx, err) => {
+    const timestamp = input.now();
+    input.stderr(
+      buildDaemonLogLine({
+        level,
+        message,
+        now: timestamp,
+        ctx,
+        err
+      }).trimEnd()
+    );
+    submitFileRecord(
+      capUtf8Record(
+        buildDaemonFileLogLine(
+          { level, message, now: timestamp, ctx, err },
+          input.runId,
+          input.pid
+        ),
+        input.policy.maxRecordBytes
+      )
+    );
+  }, "tee");
+  const finalize = /* @__PURE__ */ __name(async () => {
+    await pending;
+    const summary = unreportedDropRecord();
+    if (summary && !input.state.poisoned && !input.family.lease.compromised) {
+      if (await appendActive(summary) === "written") {
+        reportedDroppedRecords = droppedRecords;
+        reportedDroppedBytes = droppedBytes;
+      }
+    }
+    if (input.family.mode === "fallback") {
+      await closeFallbackFamily({
+        ...input,
+        onRetentionError: markRetentionFailure
+      });
+    } else {
+      await input.family.releaseLease().catch((error) => {
+        input.warnOnce(
+          "release-failed",
+          `qwen serve: daemon log lease release failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      });
+    }
+  }, "finalize");
+  const logger = {
+    info: /* @__PURE__ */ __name((message, ctx) => tee("INFO", message, ctx), "info"),
+    warn: /* @__PURE__ */ __name((message, ctx) => tee("WARN", message, ctx), "warn"),
+    error: /* @__PURE__ */ __name((message, err, ctx) => tee("ERROR", message, ctx, err ?? void 0), "error"),
     raw: /* @__PURE__ */ __name((line, level = "info") => {
-      const upper = level.toUpperCase();
-      const formatted = `${now().toISOString()} [${upper}] [DAEMON] ${line}
-`;
-      enqueueAppend(formatted);
+      submitFileRecord(
+        capUtf8Record(
+          buildDaemonFileLogLine(
+            {
+              level: level.toUpperCase(),
+              message: line,
+              now: input.now()
+            },
+            input.runId,
+            input.pid
+          ),
+          input.policy.maxRecordBytes
+        )
+      );
     }, "raw"),
-    getLogPath: /* @__PURE__ */ __name(() => logPath, "getLogPath"),
-    getDaemonId: /* @__PURE__ */ __name(() => daemonId, "getDaemonId"),
-    flush: /* @__PURE__ */ __name(() => pending, "flush")
+    getLogPath: /* @__PURE__ */ __name(() => input.family.activePath, "getLogPath"),
+    getDaemonId: /* @__PURE__ */ __name(() => input.daemonId, "getDaemonId"),
+    getStatus: /* @__PURE__ */ __name(() => statusSnapshot(
+      input.runId,
+      input.family.mode,
+      input.issues,
+      droppedRecords,
+      droppedBytes
+    ), "getStatus"),
+    flush: /* @__PURE__ */ __name(() => pending, "flush"),
+    close: /* @__PURE__ */ __name(() => {
+      if (closePromise) return closePromise;
+      acceptingFileRecords = false;
+      const finalizer = finalize().catch((error) => {
+        try {
+          input.warnOnce(
+            "close-failed",
+            `qwen serve: daemon log close failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        } catch {
+        }
+      });
+      let timeout;
+      const deadline = new Promise((resolve) => {
+        timeout = setTimeout(() => {
+          try {
+            input.warnOnce(
+              "close-timeout",
+              `qwen serve: daemon log close drain exceeded ${input.policy.closeDrainBudgetMs}ms; ownership will release after pending I/O settles or process exit`
+            );
+          } catch {
+          } finally {
+            resolve();
+          }
+        }, input.policy.closeDrainBudgetMs);
+        timeout.unref();
+      });
+      closePromise = Promise.race([finalizer, deadline]).then(() => {
+        if (timeout) clearTimeout(timeout);
+      });
+      return closePromise;
+    }, "close")
   };
+  return { logger, writeInitialRecord: appendActive };
+}
+__name(createConcreteLogger, "createConcreteLogger");
+async function initDaemonLogger(opts) {
+  const pid = opts.pid ?? process.pid;
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const monotonicNow = opts.monotonicNow ?? (() => performance.now());
+  const stderr = opts.stderr ?? writeStderrLine;
+  const baseDir = opts.baseDir ?? resolveDaemonLogBaseDir();
+  const runId = opts.runId ?? crypto.randomBytes(16).toString("hex");
+  const policy = resolvePolicy(opts.policy);
+  const fs2 = opts.fs ?? nodeFs.promises;
+  const acquireLock = opts.acquireLock ?? import_proper_lockfile.default.lock;
+  const issues = /* @__PURE__ */ new Set();
+  const warned = /* @__PURE__ */ new Set();
+  const warnOnce = /* @__PURE__ */ __name((key, message) => {
+    if (warned.has(key)) return;
+    warned.add(key);
+    try {
+      stderr(message);
+    } catch {
+    }
+  }, "warnOnce");
+  if (isOptedOut()) {
+    return createStderrOnlyLogger({
+      runId,
+      daemonId: computeDaemonId(pid),
+      now,
+      stderr,
+      issues
+    });
+  }
+  const daemonDir = nodePath.join(baseDir, "daemon");
+  try {
+    await ensureRealDirectory(fs2, daemonDir);
+  } catch (error) {
+    issues.add("init_failed");
+    warnOnce(
+      "init",
+      `qwen serve: daemon log disabled \u2014 init failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return createStderrOnlyLogger({
+      runId,
+      daemonId: computeDaemonId(pid),
+      now,
+      stderr,
+      issues
+    });
+  }
+  let currentState;
+  const onCompromised = /* @__PURE__ */ __name((error) => {
+    issues.add("lease_compromised");
+    if (currentState) currentState.poisoned = true;
+    warnOnce(
+      "lease-compromised",
+      `qwen serve: daemon log lease compromised; file logging disabled for this run: ${error.message}`
+    );
+  }, "onCompromised");
+  const tryFamily = /* @__PURE__ */ __name(async (family) => {
+    let state;
+    try {
+      const currentBytes = await activeFileSize(fs2, family.activePath);
+      if (family.mode === "fallback" && currentBytes !== 0) {
+        throw new Error(
+          "New fallback family unexpectedly contains an active log"
+        );
+      }
+      const completeTail = await lastByteIsNewline(
+        fs2,
+        family.activePath,
+        currentBytes
+      );
+      let archiveAvailable = true;
+      let archives = [];
+      const familyMutationAllowed = /* @__PURE__ */ __name(() => !family.lease.compromised && !family.lease.released, "familyMutationAllowed");
+      try {
+        await ensureRealDirectory(fs2, family.archiveDir, familyMutationAllowed);
+        if (!familyMutationAllowed()) {
+          throw new Error("Daemon log family lease was compromised");
+        }
+        archives = await scanArchives(fs2, family.archiveDir);
+      } catch (error) {
+        archiveAvailable = false;
+        if (familyMutationAllowed()) {
+          issues.add("rotation_failed");
+          warnOnce(
+            `archive-init:${family.mode}`,
+            `qwen serve: daemon log archive unavailable; active file will remain bounded: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      state = {
+        currentBytes,
+        archives,
+        nextArchiveGeneration: (archives.at(-1)?.generation ?? 0) + 1,
+        archiveAvailable,
+        exclusiveBootCreate: family.mode === "fallback",
+        poisoned: false,
+        nextRotationRetryAt: archiveAvailable ? 0 : monotonicNow() + policy.rotationRetryIntervalMs
+      };
+      currentState = state;
+      const concrete = createConcreteLogger({
+        fs: fs2,
+        acquireLock,
+        policy,
+        family,
+        state,
+        runId,
+        pid,
+        daemonId: computeDaemonId(pid),
+        now,
+        monotonicNow,
+        stderr,
+        issues,
+        warnOnce
+      });
+      const bootCtx = {
+        workspace: opts.boundWorkspace,
+        workspaceHash: computeWorkspaceHash(opts.boundWorkspace)
+      };
+      const bootTime = now();
+      const plainBoot = capUtf8Record(
+        buildDaemonFileLogLine(
+          {
+            level: "INFO",
+            message: "daemon started",
+            now: bootTime,
+            ctx: bootCtx
+          },
+          runId,
+          pid
+        ),
+        policy.maxRecordBytes
+      );
+      const incompleteTailBoot = !completeTail ? `
+${capUtf8Record(
+        buildDaemonFileLogLine(
+          {
+            level: "INFO",
+            message: "daemon started",
+            now: bootTime,
+            ctx: { ...bootCtx, previousTailIncomplete: true }
+          },
+          runId,
+          pid
+        ),
+        policy.maxRecordBytes - 1
+      )}` : plainBoot;
+      const wouldRotate = currentBytes > 0 && currentBytes + Buffer.byteLength(incompleteTailBoot, "utf8") > policy.maxBytes;
+      const bootRecord = !completeTail && !wouldRotate ? incompleteTailBoot : plainBoot;
+      const bootOutcome = await concrete.writeInitialRecord(
+        bootRecord,
+        wouldRotate
+      );
+      if (bootOutcome !== "written" || state.poisoned || family.lease.compromised) {
+        return void 0;
+      }
+      if (state.archiveAvailable && state.archives.length > policy.maxArchives) {
+        try {
+          while (state.archives.length > policy.maxArchives) {
+            if (family.lease.compromised || family.lease.released) break;
+            const oldest = state.archives[0];
+            if (!oldest) break;
+            try {
+              await fs2.unlink(nodePath.join(family.archiveDir, oldest.name));
+            } catch (error) {
+              if (!isErrno(error, "ENOENT")) throw error;
+            }
+            state.archives.shift();
+          }
+        } catch (error) {
+          issues.add("retention_failed");
+          state.nextRotationRetryAt = monotonicNow() + policy.rotationRetryIntervalMs;
+          warnOnce(
+            "startup-retention",
+            `qwen serve: daemon log retention cleanup failed: ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      return concrete.logger;
+    } catch (error) {
+      warnOnce(
+        `family-init:${family.mode}`,
+        `qwen serve: daemon ${family.mode} log initialization failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return void 0;
+    }
+  }, "tryFamily");
+  try {
+    const stableLease = await acquireLease({
+      fs: fs2,
+      acquireLock,
+      targetPath: daemonDir,
+      lockPath: nodePath.join(daemonDir, ".stable-writer.lock"),
+      policy,
+      retryBudgetMs: policy.stableAcquireBudgetMs,
+      onCompromised
+    });
+    const stableFamily = {
+      mode: "stable",
+      activePath: nodePath.join(daemonDir, "daemon.log"),
+      archiveDir: nodePath.join(daemonDir, "archive"),
+      familyDir: daemonDir,
+      lease: stableLease,
+      releaseLease: stableLease.release
+    };
+    const stableLogger = await tryFamily(stableFamily);
+    if (stableLogger) {
+      if (!stableLease.compromised && !stableLease.released) {
+        await updateLatestBestEffort(
+          fs2,
+          daemonDir,
+          stableFamily.activePath,
+          () => !stableLease.compromised && !stableLease.released
+        );
+      }
+      if (!stableLease.compromised && !stableLease.released) {
+        await cleanupFallbacksBestEffort({
+          fs: fs2,
+          acquireLock,
+          policy,
+          daemonDir,
+          mutationAllowed: /* @__PURE__ */ __name(() => !stableLease.compromised && !stableLease.released, "mutationAllowed"),
+          onRetentionError: /* @__PURE__ */ __name((error) => {
+            issues.add("retention_failed");
+            warnOnce(
+              "fallback-retention",
+              `qwen serve: daemon fallback log cleanup failed: ${error instanceof Error ? error.message : String(error)}`
+            );
+          }, "onRetentionError")
+        });
+      }
+      return stableLogger;
+    }
+    issues.add("init_failed");
+    try {
+      await stableLease.release();
+    } catch (error) {
+      warnOnce(
+        "stable-release",
+        `qwen serve: daemon stable log lease release failed; trying fallback: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  } catch (error) {
+    if (isErrno(error, "ELOCKED")) {
+      warnOnce(
+        "stable-contention",
+        `qwen serve: daemon stable log is owned by another daemon instance; using a fallback log for runId=${runId}`
+      );
+    } else {
+      issues.add("init_failed");
+      warnOnce(
+        "stable-lock",
+        `qwen serve: daemon stable log unavailable; trying a fallback: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  let fallbackFamily;
+  try {
+    fallbackFamily = await allocateFallbackFamily({
+      fs: fs2,
+      acquireLock,
+      policy,
+      daemonDir,
+      runId,
+      onCompromised
+    });
+    const activeFallbackFamily = fallbackFamily;
+    const fallbackLogger = await tryFamily(activeFallbackFamily);
+    if (!fallbackLogger) {
+      issues.add("init_failed");
+      await removeFailedFallbackBestEffort({
+        fs: fs2,
+        acquireLock,
+        policy,
+        family: activeFallbackFamily
+      });
+      return createStderrOnlyLogger({
+        runId,
+        daemonId: computeDaemonId(pid),
+        now,
+        stderr,
+        issues
+      });
+    }
+    const runsDir = nodePath.dirname(activeFallbackFamily.familyDir);
+    try {
+      if (activeFallbackFamily.lease.compromised) return fallbackLogger;
+      const maintenance = await acquireMaintenanceLease({
+        fs: fs2,
+        acquireLock,
+        policy,
+        runsDir,
+        retryBudgetMs: 0
+      });
+      try {
+        if (!activeFallbackFamily.lease.compromised) {
+          await writeRecentFallback(
+            fs2,
+            runsDir,
+            nodePath.basename(activeFallbackFamily.familyDir),
+            () => !maintenance.compromised && !maintenance.released && !activeFallbackFamily.lease.compromised
+          );
+        }
+      } finally {
+        await maintenance.release();
+      }
+    } catch (error) {
+      warnOnce(
+        "fallback-locator",
+        `qwen serve: daemon fallback locator update failed; use ${activeFallbackFamily.activePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    return fallbackLogger;
+  } catch (error) {
+    issues.add("init_failed");
+    await fallbackFamily?.releaseLease().catch(() => {
+    });
+    warnOnce(
+      "fallback-init",
+      `qwen serve: daemon log disabled \u2014 fallback init failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return createStderrOnlyLogger({
+      runId,
+      daemonId: computeDaemonId(pid),
+      now,
+      stderr,
+      issues
+    });
+  }
 }
 __name(initDaemonLogger, "initDaemonLogger");
 
@@ -941,6 +2135,30 @@ var QWEN_SERVE_CDP_TUNNEL_OVER_WS_ENV = "QWEN_SERVE_CDP_TUNNEL_OVER_WS";
 var QWEN_SERVE_PROMPT_DEADLINE_MS_ENV = "QWEN_SERVE_PROMPT_DEADLINE_MS";
 var QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS_ENV = "QWEN_SERVE_WRITER_IDLE_TIMEOUT_MS";
 var SHUTDOWN_FORCE_CLOSE_MS = 5e3;
+var DAEMON_LOG_FORCED_FLUSH_BUDGET_MS = 250;
+async function flushDaemonLogBounded(daemonLog, budgetMs) {
+  let timer;
+  try {
+    await Promise.race([
+      daemonLog.flush().catch(() => {
+      }),
+      new Promise((resolve) => {
+        timer = setTimeout(resolve, budgetMs);
+        timer.unref();
+      })
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+__name(flushDaemonLogBounded, "flushDaemonLogBounded");
+function writeDaemonLifecycleBestEffort(write) {
+  try {
+    write();
+  } catch {
+  }
+}
+__name(writeDaemonLifecycleBestEffort, "writeDaemonLifecycleBestEffort");
 function daemonPipeDirection(direction) {
   switch (direction) {
     case "sent":
@@ -1139,12 +2357,12 @@ __name(withSettingsLock, "withSettingsLock");
 var channelWorkerRuntimePromise;
 async function loadChannelWorkerRuntime() {
   channelWorkerRuntimePromise ??= Promise.all([
-    import("./channel-worker-supervisor-JA6VZ5V5.js"),
-    import("./pidfile-WKUVXDMR.js"),
-    import("./runtime-6IVKJSLW.js"),
+    import("./channel-worker-supervisor-ZGO2W2MD.js"),
+    import("./pidfile-MVZDE5TC.js"),
+    import("./runtime-4KGNL3TP.js"),
     import("./cli-entry-path-4VJ3Y6T2.js"),
-    import("./channel-worker-group-S3H5QHTI.js"),
-    import("./channel-worker-manager-ZJ4HTMO2.js")
+    import("./channel-worker-group-53CMOPFT.js"),
+    import("./channel-worker-manager-UTXILKC2.js")
   ]).then(
     ([
       supervisor,
@@ -1249,7 +2467,7 @@ function shouldPreheatBridge(deps) {
 __name(shouldPreheatBridge, "shouldPreheatBridge");
 var coreRuntimePromise;
 function loadCoreRuntime() {
-  coreRuntimePromise ??= import("./src-ADLNIPHD.js");
+  coreRuntimePromise ??= import("./src-DUFUUEHE.js");
   return coreRuntimePromise;
 }
 __name(loadCoreRuntime, "loadCoreRuntime");
@@ -1279,10 +2497,10 @@ __name(resolveDaemonLogBaseDirForRun, "resolveDaemonLogBaseDirForRun");
 var settingsRuntimePromise;
 function loadSettingsRuntimeModules() {
   settingsRuntimePromise ??= Promise.all([
-    import("./settings-ZX3OKUT4.js"),
-    import("./environment-LOCDCWMZ.js"),
-    import("./loadedSettingsAdapter-446B6WKA.js"),
-    import("./trustedFolders-CY4TUPDJ.js")
+    import("./settings-H5O22TGQ.js"),
+    import("./environment-KHS35XJY.js"),
+    import("./loadedSettingsAdapter-3DUNHAPX.js"),
+    import("./trustedFolders-ANQXYAQT.js")
   ]).then(([settings, environment, loadedSettingsAdapter, trustedFolders]) => ({
     settings,
     environment,
@@ -1295,8 +2513,8 @@ __name(loadSettingsRuntimeModules, "loadSettingsRuntimeModules");
 var channelWebhookConfigRuntimePromise;
 function loadChannelWebhookConfigRuntime() {
   channelWebhookConfigRuntimePromise ??= Promise.all([
-    import("./runtime-6IVKJSLW.js"),
-    import("./config-utils-KWTRFP7D.js")
+    import("./runtime-4KGNL3TP.js"),
+    import("./config-utils-AHQ6YZ66.js")
   ]).then(([channelRuntime, configUtils]) => ({
     loadChannelsConfig: channelRuntime.loadChannelsConfig,
     parseChannelWebhookConfig: configUtils.parseChannelWebhookConfig
@@ -1320,16 +2538,16 @@ async function loadServeRuntimeModules() {
     totalSessionAdmissionModule,
     workspaceRegistryModule
   ] = await Promise.all([
-    import("./server-AA24QLPA.js"),
-    import("./bridge-ATN2TLWJ.js"),
-    import("./spawnChannel-6WFOK3SA.js"),
-    import("./workspace-service-6ZEUJY2Z.js"),
+    import("./server-RTJUMN24.js"),
+    import("./bridge-OW5FZ6BF.js"),
+    import("./spawnChannel-G7DUQKHL.js"),
+    import("./workspace-service-JJNJWVH3.js"),
     import("./types-ML3TRJQ5.js"),
-    import("./daemon-status-provider-GTZOYSBO.js"),
-    import("./workspace-providers-status-UHQOIPAZ.js"),
-    import("./workspace-skills-status-YG6OITSM.js"),
-    import("./total-session-admission-S6ATY5HY.js"),
-    import("./workspace-registry-LAQCRQTH.js")
+    import("./daemon-status-provider-L5UW7TGV.js"),
+    import("./workspace-providers-status-XCQKBVSX.js"),
+    import("./workspace-skills-status-CEHLAQ2Y.js"),
+    import("./total-session-admission-KOPTGDJZ.js"),
+    import("./workspace-registry-N4J57SFQ.js")
   ]);
   return {
     createServeApp: serverModule.createServeApp,
@@ -1640,12 +2858,21 @@ function createBootstrapServeApp(input) {
       severity: "warning",
       message: "Daemon runtime is still starting."
     };
+    const daemonLogStatus = daemonLog.getStatus();
+    const issues = [issue];
+    if (daemonLogStatus.health === "degraded") {
+      issues.push({
+        code: "daemon_log_degraded",
+        severity: "warning",
+        message: "Daemon file logging is degraded; inspect full status for details."
+      });
+    }
     const response = {
       v: 1,
       detail: detail.detail,
       generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
       status: runtimeFailed ? "error" : "warning",
-      issues: [issue],
+      issues,
       daemon: {
         pid: process.pid,
         uptimeMs: Math.round(process.uptime() * 1e3),
@@ -1657,7 +2884,15 @@ function createBootstrapServeApp(input) {
         },
         ...qwenCodeVersion ? { qwenCodeVersion } : {},
         ...daemonLog.getDaemonId() ? { daemonId: daemonLog.getDaemonId() } : {},
-        ...detail.detail === "full" && daemonLog.getLogPath() ? { logPath: daemonLog.getLogPath() } : {}
+        runId: daemonLogStatus.runId,
+        logMode: daemonLogStatus.mode,
+        logHealth: daemonLogStatus.health,
+        ...detail.detail === "full" && daemonLog.getLogPath() ? { logPath: daemonLog.getLogPath() } : {},
+        ...detail.detail === "full" ? {
+          logIssues: daemonLogStatus.issues,
+          logDroppedRecords: daemonLogStatus.droppedRecords,
+          logDroppedBytes: daemonLogStatus.droppedBytes
+        } : {}
       },
       security: {
         tokenConfigured: Boolean(opts.token),
@@ -1761,7 +2996,7 @@ function createDelegatingServeApp(bootstrapApp, getRuntimeApp, options = {}) {
     const dispatch = /* @__PURE__ */ __name(async () => {
       let target = getRuntimeApp();
       if (!target && options.waitForDeferredRuntimeRoutes === true && !isBootstrapServeRoute(req) && !isCorsPreflightRequest(req) && options.startRuntime && options.runtimeReady) {
-        const waitStartedAt = performance.now();
+        const waitStartedAt = performance2.now();
         const timing = {
           startedAt: /* @__PURE__ */ new Date(),
           path: "joined"
@@ -1781,7 +3016,7 @@ function createDelegatingServeApp(bootstrapApp, getRuntimeApp, options = {}) {
           await options.runtimeReady;
         } catch {
         } finally {
-          timing.waitMs = Math.round((performance.now() - waitStartedAt) * 100) / 100;
+          timing.waitMs = Math.round((performance2.now() - waitStartedAt) * 100) / 100;
         }
         target = getRuntimeApp();
       }
@@ -1894,7 +3129,37 @@ function runSynchronousRequestGate(handler, req, res, next) {
 }
 __name(runSynchronousRequestGate, "runSynchronousRequestGate");
 async function runQwenServe(optsIn, deps = {}) {
-  const runStartedAt = performance.now();
+  let daemonLog;
+  let owner = "startup";
+  try {
+    return await runQwenServeImpl(optsIn, deps, {
+      initialized: /* @__PURE__ */ __name((logger) => {
+        daemonLog = logger;
+      }, "initialized"),
+      published: /* @__PURE__ */ __name(() => {
+        if (owner === "startup") owner = "handle";
+      }, "published"),
+      signalOwned: /* @__PURE__ */ __name(() => {
+        if (owner === "startup") owner = "signal";
+      }, "signalOwned")
+    });
+  } catch (error) {
+    if (daemonLog && owner === "startup") {
+      const startupLog = daemonLog;
+      writeDaemonLifecycleBestEffort(
+        () => startupLog.error(
+          "daemon startup failed",
+          error instanceof Error ? error : new Error(String(error))
+        )
+      );
+      await startupLog.close();
+    }
+    throw error;
+  }
+}
+__name(runQwenServe, "runQwenServe");
+async function runQwenServeImpl(optsIn, deps, loggerLifecycle) {
+  const runStartedAt = performance2.now();
   const shouldPreheat = !deps.bridge && shouldPreheatBridge(deps);
   const startup = {
     processStartedAt: new Date(
@@ -2160,7 +3425,7 @@ async function runQwenServe(optsIn, deps = {}) {
   }
   let workspaceRegistrationStore = deps.workspaceRegistrationStore;
   if (workspaceRegistrationStore === void 0 && process.env["QWEN_SERVE_NO_PERSISTENT_REGISTRATION"] !== "1") {
-    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-5WPCMX4F.js");
+    const { WorkspaceRegistrationStore } = await import("./workspace-registration-store-4I4KL7TN.js");
     workspaceRegistrationStore = new WorkspaceRegistrationStore(boundWorkspace);
   }
   if (workspaceRegistrationStore) {
@@ -2251,10 +3516,13 @@ async function runQwenServe(optsIn, deps = {}) {
     bootSettings,
     boundWorkspace
   });
-  const daemonLog = initDaemonLogger({
+  const daemonLog = await initDaemonLogger({
     boundWorkspace,
     baseDir: daemonLogBaseDir
   });
+  loggerLifecycle.initialized(daemonLog);
+  let loggerPublished = false;
+  let loggerSignalOwned = false;
   writeStderrLine(
     `qwen serve: daemon log \u2192 ${daemonLog.getLogPath() || "(disabled)"}`
   );
@@ -3008,7 +4276,7 @@ async function runQwenServe(optsIn, deps = {}) {
         );
       }
     }), "persistSettingsFn");
-    const { createSubSessionLauncher } = await import("./create-sub-session-OT7WXLDO.js");
+    const { createSubSessionLauncher } = await import("./create-sub-session-BVL2ZHTM.js");
     const subSessionLauncher = createSubSessionLauncher({
       getBridge: /* @__PURE__ */ __name(() => bridgeRef, "getBridge"),
       boundWorkspace
@@ -4004,7 +5272,7 @@ async function runQwenServe(optsIn, deps = {}) {
       startup.listenerReadyAt = (/* @__PURE__ */ new Date()).toISOString();
       startup.processToListenMs = Math.round(process.uptime() * 1e3);
       startup.runQwenServeToListenMs = Math.round(
-        performance.now() - runStartedAt
+        performance2.now() - runStartedAt
       );
       profileCheckpoint("serve_listener_ready");
       finalizeStartupProfile(`serve-${process.pid}`);
@@ -4340,17 +5608,17 @@ async function runQwenServe(optsIn, deps = {}) {
       }, "completeRuntimeStartup");
       const startBridgePreheat = /* @__PURE__ */ __name((bridge) => {
         startup.preheat.status = "running";
-        const preheatStartedAt = performance.now();
+        const preheatStartedAt = performance2.now();
         bridge.preheat().then(() => {
           startup.preheat.status = "succeeded";
           startup.preheat.durationMs = Math.round(
-            performance.now() - preheatStartedAt
+            performance2.now() - preheatStartedAt
           );
         }).catch((err) => {
           const message = err instanceof Error ? err.message : String(err);
           startup.preheat.status = "failed";
           startup.preheat.durationMs = Math.round(
-            performance.now() - preheatStartedAt
+            performance2.now() - preheatStartedAt
           );
           startup.preheat.error = message;
           writeStderrLine(
@@ -4430,28 +5698,33 @@ async function runQwenServe(optsIn, deps = {}) {
               err instanceof Error ? err : null
             );
           }
-          await daemonLog.flush().catch(() => {
-          });
+          await flushDaemonLogBounded(
+            daemonLog,
+            DAEMON_LOG_FORCED_FLUSH_BUDGET_MS
+          );
           process.exit(1);
           return;
         }
+        if (!loggerPublished) {
+          loggerSignalOwned = true;
+          loggerLifecycle.signalOwned();
+        }
         daemonLog.warn(`received ${signal}, draining`);
         try {
           await handle.close();
-          await daemonLog.flush();
           process.exit(runtimeStartupError === void 0 ? 0 : 1);
         } catch (err) {
           daemonLog.error("shutdown error", err instanceof Error ? err : null);
-          await daemonLog.flush().catch(() => {
-          });
           if (channelWorkerManager?.state().enabled) {
             daemonLog.error(
               "refusing to exit while a channel worker or service lease remains; signal again to retry after the child exits (another signal during that retry forces exit)"
             );
-            await daemonLog.flush().catch(() => {
-            });
             return;
           }
+          await flushDaemonLogBounded(
+            daemonLog,
+            DAEMON_LOG_FORCED_FLUSH_BUDGET_MS
+          );
           process.exit(1);
         }
       }, "onSignal");
@@ -4484,6 +5757,8 @@ async function runQwenServe(optsIn, deps = {}) {
             const finish = /* @__PURE__ */ __name((err) => {
               if (settled) return;
               settled = true;
+              const accessLogController = (runtimeApp ?? runtimeAppForCleanup)?.locals?.[ACCESS_LOG_CONTROLLER_LOCAL];
+              accessLogController?.sealAndFlushSuppressed();
               const preserveSignalHandlers = channelWorkerShutdownError !== void 0 && channelWorkerManager?.state().enabled === true;
               if (!preserveSignalHandlers) {
                 process.removeListener("SIGINT", onSignal);
@@ -4497,19 +5772,28 @@ async function runQwenServe(optsIn, deps = {}) {
                 writeStderrLine(
                   `qwen serve: telemetry shutdown error: ${telemetryErr instanceof Error ? telemetryErr.message : String(telemetryErr)}`
                 );
-              }).finally(() => daemonLog.flush().catch(() => {
-              })).finally(() => {
+              }).finally(async () => {
                 const finalErr = err ?? bridgeShutdownError ?? channelWorkerShutdownError;
-                if (finalErr) {
-                  if (channelWorkerShutdownError && channelWorkerManager?.state().enabled) {
-                    closePromise = void 0;
-                    shuttingDown = false;
-                    channelControlDraining = false;
-                  }
+                const retryableChannelClose = channelWorkerShutdownError !== void 0 && channelWorkerManager?.state().enabled === true;
+                if (retryableChannelClose) {
+                  await flushDaemonLogBounded(
+                    daemonLog,
+                    DAEMON_LOG_FORCED_FLUSH_BUDGET_MS
+                  );
+                  closePromise = void 0;
+                  shuttingDown = false;
+                  channelControlDraining = false;
                   rej(finalErr);
-                } else {
-                  res();
+                  return;
+                }
+                if (loggerPublished || loggerSignalOwned) {
+                  writeDaemonLifecycleBestEffort(
+                    () => daemonLog.info("daemon stopped")
+                  );
+                  await daemonLog.close();
                 }
+                if (finalErr) rej(finalErr);
+                else res();
               });
             }, "finish");
             void (coreRuntimePromise ? coreRuntimePromise.then((core) => core.forceFlushMetrics()) : Promise.resolve()).catch((flushErr) => {
@@ -4638,23 +5922,33 @@ async function runQwenServe(optsIn, deps = {}) {
         startRuntime();
       }
       if (deps.resolveOnListen) {
+        loggerPublished = true;
+        loggerLifecycle.published();
         resolve(handle);
       } else {
         void runtimeReady.then(
-          () => resolve(handle),
+          () => {
+            loggerPublished = true;
+            loggerLifecycle.published();
+            resolve(handle);
+          },
           (err) => {
             void handle.close().then(
               () => {
                 reject(err instanceof Error ? err : new Error(String(err)));
               },
               (closeErr) => {
-                daemonLog.error(
-                  "shutdown after runtime startup error failed",
-                  closeErr instanceof Error ? closeErr : null
+                writeDaemonLifecycleBestEffort(
+                  () => daemonLog.error(
+                    "shutdown after runtime startup error failed",
+                    closeErr instanceof Error ? closeErr : null
+                  )
                 );
                 if (channelWorkerManager?.state().enabled) {
-                  daemonLog.error(
-                    "runtime startup failed, but qwen serve remains alive to retain the channel service lease until worker exit is confirmed"
+                  writeDaemonLifecycleBestEffort(
+                    () => daemonLog.error(
+                      "runtime startup failed, but qwen serve remains alive to retain the channel service lease until worker exit is confirmed"
+                    )
                   );
                   return;
                 }
@@ -4714,7 +6008,7 @@ async function runQwenServe(optsIn, deps = {}) {
     tryListen(opts.port, 0);
   });
 }
-__name(runQwenServe, "runQwenServe");
+__name(runQwenServeImpl, "runQwenServeImpl");
 export {
   InvalidPolicyConfigError,
   createDisabledChannelWorkerSupervisor,