niuma-codex 0.0.1-beta.28 → 0.0.1-beta.29

package/dist/managed.js

@@ -8485,9 +8485,42 @@ function parseAttachmentTaskV2StatusQuery(value) {
   return { ...parseAttachmentTaskStatusQuery(normalize(value, true)), version: 2 };
 }
 
+// packages/protocol/src/thread-load-trace.ts
+var CLIENT_LOAD_PHASES = ["selected", "restored", "request_started", "snapshot_received", "history_ready", "content_presented"];
+function object8(value, required, optional = []) {
+  if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) throw new TypeError("invalid_load_report");
+  const descriptors = Object.getOwnPropertyDescriptors(value);
+  if (Reflect.ownKeys(value).some((key) => typeof key !== "string" || ![...required, ...optional].includes(key)) || required.some((key) => !Object.hasOwn(descriptors, key)) || Object.values(descriptors).some((d) => !d.enumerable || !("value" in d))) throw new TypeError("invalid_load_report");
+  return value;
+}
+function timing(value) {
+  if (!Number.isInteger(value.elapsed_ms) || value.elapsed_ms < 0 || value.elapsed_ms > 9e5 || value.occurred_at_ms !== void 0 && (!Number.isInteger(value.occurred_at_ms) || value.occurred_at_ms < 1 || value.occurred_at_ms > 864e13)) throw new TypeError("invalid_load_timing");
+}
+function parseThreadLoadReportV2(value) {
+  const v = object8(value, ["version", "thread_id", "load_id", "client_class", "samples"], ["terminal"]);
+  if (v.version !== 2 || typeof v.thread_id !== "string" || !v.thread_id.length || v.thread_id.length > 256 || typeof v.load_id !== "string" || !/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(v.load_id) || !["web", "ios", "other"].includes(v.client_class) || !Array.isArray(v.samples) || v.samples.length > 6 || !v.samples.length && v.terminal === void 0) throw new TypeError("invalid_load_report");
+  for (const sample of v.samples) {
+    const s = object8(sample, ["phase", "elapsed_ms"], ["occurred_at_ms"]);
+    timing(s);
+    if (!CLIENT_LOAD_PHASES.includes(s.phase)) throw new TypeError("invalid_load_phase");
+  }
+  if (v.terminal !== void 0) {
+    const t = object8(v.terminal, ["kind", "phase", "reason", "elapsed_ms"], ["occurred_at_ms"]);
+    timing(t);
+    const reasons = { failed: ["open_rejected", "history_failed"], cancelled: ["left_view", "user_cancelled"], superseded: ["stream_replaced"] };
+    if (!["request_started", "snapshot_received", "history_ready"].includes(t.phase) || !Object.hasOwn(reasons, t.kind) || !reasons[t.kind]?.includes(t.reason) || v.samples.some((s) => s.phase === "content_presented")) throw new TypeError("invalid_load_terminal");
+  }
+  return v;
+}
+function reduceThreadLoadOutcome(current2, event) {
+  if (event === "closed" || event === "expired") return current2.status === "loading" ? { ...current2, status: "incomplete" } : current2;
+  if (current2.status === "loading" || current2.status === "incomplete" && ["cancelled", "superseded"].includes(event)) return { ...current2, status: event };
+  return current2.status === event ? current2 : { ...current2, conflict: true };
+}
+
 // apps/desktop/src/release-version.ts
 function desktopReleaseVersion() {
-  return false ? null : "0.0.1-beta.28";
+  return false ? null : "0.0.1-beta.29";
 }
 var sourcePresenceVersion = (() => {
   if (true) return null;
@@ -11986,6 +12019,59 @@ function discoverDirectGatewayOrigins(host, port, interfaces = networkInterfaces
 // apps/desktop/src/daemon/launcher.ts
 var BACKGROUND_DAEMON_STARTUP_TIMEOUT_MS = Math.max(6e4, desktopPlatform().daemon.startupTimeoutMs);
 
+// apps/desktop/src/daemon/runtime/ipc-thread-discovery.ts
+var RuntimeIpcThreadDiscovery = class {
+  constructor(ports) {
+    this.ports = ports;
+  }
+  ports;
+  pending = /* @__PURE__ */ new Map();
+  discover(id5) {
+    const started2 = Date.now();
+    const report = (phase) => {
+      try {
+        this.ports.diagnostic(id5, phase, Date.now() - started2);
+      } catch {
+      }
+    };
+    if (!this.ports.eligible(id5)) {
+      report("ignored");
+      return;
+    }
+    if (this.pending.has(id5)) {
+      report("deduplicated");
+      return;
+    }
+    if (this.pending.size >= 66) {
+      report("capacity");
+      return;
+    }
+    const current2 = this.ports.capture();
+    report("received");
+    const task = this.run(id5, current2, report).catch(() => report("failed")).finally(() => {
+      if (this.pending.get(id5) === task) this.pending.delete(id5);
+    });
+    this.pending.set(id5, task);
+  }
+  async run(id5, current2, report) {
+    const result = await this.ports.read(id5);
+    report("read_completed");
+    const valid = () => current2() && this.ports.eligible(id5) && result.kind === "ordinary" && result.summary?.id === id5 && !!result.token && this.ports.current(result.token);
+    if (!valid()) {
+      report("rejected");
+      return;
+    }
+    await this.ports.enqueue(() => {
+      if (!valid()) {
+        report("stale");
+        return;
+      }
+      this.ports.commit(result.summary);
+      report("published");
+    });
+  }
+};
+
 // apps/desktop/src/daemon/async-question-response.ts
 import { createHash } from "node:crypto";
 function submissionId(input) {
@@ -14763,11 +14849,11 @@ var RuntimeActivityPublication = class {
     if (!thread4) {
       return null;
     }
-    const timing = this.ports.turnTiming(signal.threadId, signal.turnId);
-    const timingFields = timing ? {
-      turnStartedAt: timing.startedAt,
-      ...timing.endedAt !== void 0 ? { turnEndedAt: timing.endedAt } : {},
-      ...timing.outcome !== void 0 ? { turnOutcome: timing.outcome } : {}
+    const timing2 = this.ports.turnTiming(signal.threadId, signal.turnId);
+    const timingFields = timing2 ? {
+      turnStartedAt: timing2.startedAt,
+      ...timing2.endedAt !== void 0 ? { turnEndedAt: timing2.endedAt } : {},
+      ...timing2.outcome !== void 0 ? { turnOutcome: timing2.outcome } : {}
     } : {};
     if (signal.type === "turn_aborted") {
       return {
@@ -20297,7 +20383,7 @@ function fail14(reason) {
 var clone = (value) => structuredClone(value);
 var diskEntry = (entry) => ({ ...entry, nativeToken: entry.nativeToken !== null });
 var byteSize = (value) => Buffer.byteLength(JSON.stringify(value));
-function object8(value, keys3, optional = []) {
+function object9(value, keys3, optional = []) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return fail14("invalid");
   const record25 = value;
   if (Object.keys(record25).some((key) => !keys3.includes(key) && !optional.includes(key)) || !keys3.every((key) => Object.hasOwn(record25, key))) return fail14("invalid");
@@ -20331,7 +20417,7 @@ function parseReceipt(value, clientMessageId) {
   return receipt;
 }
 function parsePost(value, clientMessageId) {
-  const record25 = object8(value, ["httpStatus", "code", "message", "data"]);
+  const record25 = object9(value, ["httpStatus", "code", "message", "data"]);
   if (![200, 400, 404, 500].includes(record25.httpStatus) || !Number.isInteger(record25.code) || record25.code !== 0 && (record25.code < 1e5 || record25.code > 999999) || typeof record25.message !== "string" || record25.message.length === 0 || Buffer.byteLength(record25.message) > MAX_MESSAGE_BYTES || byteSize(record25.message) > MAX_MESSAGE_BYTES + 2) fail14("invalid");
   if (record25.code === 0) {
     if (record25.httpStatus !== 200) fail14("invalid");
@@ -20344,10 +20430,10 @@ function parsePost(value, clientMessageId) {
   } else if (record25.data !== null) {
     const data = record25.data;
     if (data.state === "unknown") {
-      object8(data, ["client_message_id", "state"]);
+      object9(data, ["client_message_id", "state"]);
       if (data.client_message_id !== clientMessageId) fail14("invalid");
     } else {
-      object8(data, ["dispatch_state"]);
+      object9(data, ["dispatch_state"]);
       if (data.dispatch_state !== "not_dispatched") fail14("invalid");
     }
   }
@@ -20380,13 +20466,13 @@ function parseDocument(raw, maxEntries) {
   } catch {
     return fail14("invalid");
   }
-  const document = object8(value, ["version", "entries"]);
+  const document = object9(value, ["version", "entries"]);
   if (document.version !== 1 || !Array.isArray(document.entries)) fail14("invalid");
   if (document.entries.length > maxEntries) fail14("capacity");
   const entries = /* @__PURE__ */ new Map();
   const nativeItems = /* @__PURE__ */ new Set();
   for (const value2 of document.entries) {
-    const record25 = object8(value2, ["principal", "threadId", "clientMessageId", "fingerprint", "nativeToken", "receipt", "firstResult", "createdAt", "updatedAt"], ["questionId"]);
+    const record25 = object9(value2, ["principal", "threadId", "clientMessageId", "fingerprint", "nativeToken", "receipt", "firstResult", "createdAt", "updatedAt"], ["questionId"]);
     if (typeof record25.nativeToken !== "boolean" || !Number.isSafeInteger(record25.createdAt) || record25.createdAt < 0 || !Number.isSafeInteger(record25.updatedAt) || record25.updatedAt < 0) fail14("invalid");
     const entry = { ...record25, nativeToken: record25.nativeToken ? record25.clientMessageId : null };
     validateReservation(entry);
@@ -20478,7 +20564,7 @@ async function openMessageSubmissionStore(options) {
     reserve(input) {
       const captured = clone(input);
       return enqueue(async () => {
-        object8(captured, ["principal", "threadId", "clientMessageId", "fingerprint", "nativeToken"], ["questionId"]);
+        object9(captured, ["principal", "threadId", "clientMessageId", "fingerprint", "nativeToken"], ["questionId"]);
         validateReservation(captured);
         const existing = entries.get(captured.clientMessageId);
         if (existing) {
@@ -23728,8 +23814,8 @@ var AppServerTransport = class {
   /** 慢响应只保留每分钟首条及抑制数；超时和协议失败仍逐次保留。 */
   auditSlowResponse(id5, pending, bytes3, failed) {
     if (!Number.isFinite(pending.startedAtMs)) return;
-    const timing = this.requestTiming(pending), now = performance.now();
-    if (timing.elapsedMs < 5e3) return;
+    const timing2 = this.requestTiming(pending), now = performance.now();
+    if (timing2.elapsedMs < 5e3) return;
     if (now - this.lastSlowAuditAtMs < 6e4) {
       this.suppressedSlowAudits++;
       return;
@@ -23740,7 +23826,7 @@ var AppServerTransport = class {
       ...typeof id5 === "number" ? { requestId: id5 } : {},
       ...isSafeErrorAuditOperation(pending.method) ? { method: pending.method } : {},
       bytes: bytes3,
-      requestTiming: timing,
+      requestTiming: timing2,
       responseDisposition: failed ? "error" : "success",
       suppressedCount: this.suppressedSlowAudits
     });
@@ -28051,7 +28137,7 @@ import { randomBytes as randomBytes3 } from "node:crypto";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "node:util";
 function logicalDescriptor(descriptor) {
   if (descriptor.pathname !== "/api/v1/thread/open") return descriptor;
-  const { load_id: _loadId, range_resume_token: _rangeToken, ...query2 } = descriptor.query;
+  const { load_id: _loadId, load_trace: _loadTrace, range_resume_token: _rangeToken, ...query2 } = descriptor.query;
   return { pathname: descriptor.pathname, query: query2 };
 }
 function fail15(code, message) {
@@ -30258,8 +30344,7 @@ function invalidPushServerOrigin() {
 function resolvePushServerOrigin(environment) {
   const value = environment.NIUMA_PUSH_SERVER_ORIGIN;
   if (value === void 0 || isBlankConfigValue(value)) {
-    const release2 = true;
-    return release2 ? DEFAULT_PUSH_PUBLIC_URL : resolveLocalServerOrigin(environment);
+    return DEFAULT_PUSH_PUBLIC_URL;
   }
   if (URL_CONTROL_OR_SPACE_PATTERN.test(value)) {
     throw invalidPushServerOrigin();
@@ -30362,6 +30447,20 @@ var ThreadLoadReportSchema = z8.object({
   load_id: z8.string().uuid(),
   samples: z8.array(LoadSampleSchema).min(1).max(6)
 }).strict();
+var ThreadLoadReportV2Schema = z8.object({
+  version: z8.literal(2),
+  thread_id: z8.string().min(1).max(256),
+  load_id: z8.string().uuid(),
+  client_class: z8.enum(["web", "ios", "other"]),
+  samples: z8.array(LoadSampleSchema).max(6),
+  terminal: z8.object({ kind: z8.enum(["failed", "cancelled", "superseded"]), phase: z8.enum(["request_started", "snapshot_received", "history_ready"]), reason: z8.enum(["open_rejected", "history_failed", "left_view", "user_cancelled", "stream_replaced"]), elapsed_ms: z8.number().int().min(0).max(9e5), occurred_at_ms: occurredAtSchema }).strict().optional()
+}).strict().superRefine((value, context) => {
+  try {
+    parseThreadLoadReportV2(value);
+  } catch {
+    context.addIssue({ code: "custom", message: "\u52A0\u8F7D\u91C7\u6837\u7EC4\u5408\u65E0\u6548" });
+  }
+});
 var LoadingTraceSchema = z8.object({
   load_id: z8.string().uuid(),
   lease_id: z8.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u),
@@ -30371,27 +30470,128 @@ var LoadingTraceSchema = z8.object({
   occurred_at_ms: occurredAtSchema
 }).strict().refine((value) => value.clock === "browser" ? ClientLoadPhaseSchema.safeParse(value.phase).success : ["open_received", "identity_ready", "lease_acquired", "shell_sent", "history_sent", "stream_closed"].includes(value.phase));
 var ThreadLoadReports = class {
-  constructor(now = Date.now) {
+  constructor(now = Date.now, audit = () => void 0) {
     this.now = now;
+    this.audit = audit;
   }
   now;
+  audit;
   entries = /* @__PURE__ */ new Map();
-  register(loadId, threadId2, owner2, record25) {
+  used = /* @__PURE__ */ new Set();
+  clear() {
+    this.entries.clear();
+  }
+  begin(input) {
+    for (const [key, value] of this.entries) if (value.expires < this.now()) this.entries.delete(key);
+    if (!z8.string().uuid().safeParse(input.loadId).success || this.entries.size >= 256 || this.used.size >= 1e4 || this.used.has(input.loadId)) return null;
+    const id5 = input.loadId;
+    const writer = this.audit();
+    if (writer?.reserveLoadId && !writer.reserveLoadId(id5)) {
+      this.used.add(id5);
+      return null;
+    }
+    this.used.add(id5);
+    const epoch = writer?.loadGeneration?.();
+    let outcome = { status: "loading", conflict: false };
+    let lease, trace;
+    const entry = { threadId: input.threadId, owner: input.owner, expires: input.nowMs + 9e5, seen: /* @__PURE__ */ new Set(), record: () => {
+    }, valid: () => this.entries.get(id5) === entry && writer?.loadGeneration?.() === epoch && this.now() <= entry.expires };
+    const write = (record25) => {
+      if (!entry.valid?.()) return;
+      try {
+        writer?.recordLoad?.({ ...record25, load_id: id5, thread_id: input.threadId, occurred_at_ms: this.now(), ...lease ? { lease_id: lease } : {}, ...trace ? { trace_id: trace } : {} });
+      } catch {
+      }
+    };
+    const end = (event) => {
+      outcome = reduceThreadLoadOutcome(outcome, event);
+      entry.expires = Math.min(entry.expires, this.now() + 3e4);
+    };
+    const elapsed = () => Math.max(0, Math.min(9e5, this.now() - input.nowMs));
+    const handle = {
+      markDaemon: (phase, elapsedMs, occurredAtMs = this.now()) => {
+        if (!entry.valid?.() || entry.seen.has("daemon:" + phase)) return;
+        entry.seen.add("daemon:" + phase);
+        write({ record_type: "load_sample", clock: "daemon", phase, elapsed_ms: elapsedMs, event_at_ms: occurredAtMs });
+      },
+      attachLease: (leaseId, traceId) => {
+        lease = leaseId;
+        trace = traceId;
+      },
+      // 每种确定终态只记一次；保留不同证据供 reducer 标示冲突，不延长授权期限。
+      finish: (kind, evidence = {}) => {
+        if (!entry.valid?.() || entry.seen.has("terminal:" + kind)) return;
+        entry.seen.add("terminal:" + kind);
+        write({ record_type: "load_terminal", clock: "daemon", phase: kind, elapsed_ms: elapsed(), ...evidence });
+        end(kind);
+      },
+      close: () => {
+        if (!entry.valid?.() || entry.seen.has("closed")) return;
+        entry.seen.add("closed");
+        write({ record_type: "load_close", clock: "daemon", phase: "closed", elapsed_ms: elapsed() });
+        end("closed");
+      },
+      outcome: () => outcome
+    };
+    entry.handle = handle;
+    entry.accept = (samples, client, terminal) => {
+      for (const sample of samples) if (!entry.seen.has("client:" + sample.phase)) {
+        entry.seen.add("client:" + sample.phase);
+        write({ record_type: "load_sample", clock: "client", phase: sample.phase, elapsed_ms: sample.elapsed_ms, ...sample.occurred_at_ms ? { event_at_ms: sample.occurred_at_ms } : {}, ...client ? { client_class: client } : {} });
+        if (sample.phase === "content_presented") end("presented");
+        try {
+          entry.record(sample);
+        } catch {
+        }
+      }
+      if (terminal && !entry.seen.has("terminal")) {
+        entry.seen.add("terminal");
+        write({ record_type: "load_terminal", clock: "client", phase: terminal.kind, terminal_phase: terminal.phase, reason: terminal.reason, elapsed_ms: terminal.elapsed_ms, ...terminal.occurred_at_ms ? { event_at_ms: terminal.occurred_at_ms } : {}, ...client ? { client_class: client } : {} });
+        end(terminal.kind);
+      }
+    };
+    this.entries.set(id5, entry);
+    write({ record_type: "load_start", clock: "daemon", phase: "open_received", elapsed_ms: 0, source_transport: input.transport });
+    return handle;
+  }
+  register(loadId, threadId2, owner2, record25, attempt) {
     for (const [key, value] of this.entries) if (value.expires < this.now()) this.entries.delete(key);
-    if (!z8.string().uuid().safeParse(loadId).success || this.entries.size >= 256 || this.entries.has(loadId)) return () => {
+    const existing = this.entries.get(loadId);
+    if (existing?.handle && existing.handle === attempt && existing.threadId === threadId2 && existing.owner === owner2) {
+      existing.record = record25;
+      return () => {
+      };
+    }
+    if (!z8.string().uuid().safeParse(loadId).success || this.entries.size >= 256 || this.used.size >= 1e4 || this.entries.has(loadId) || this.used.has(loadId)) return () => {
     };
-    const entry = { threadId: threadId2, owner: owner2, expires: this.now() + 9e5, record: record25, seen: /* @__PURE__ */ new Set() };
+    const writer = this.audit(), epoch = writer?.loadGeneration?.();
+    if (writer?.reserveLoadId && !writer.reserveLoadId(loadId)) {
+      this.used.add(loadId);
+      return () => {
+      };
+    }
+    this.used.add(loadId);
+    const entry = { threadId: threadId2, owner: owner2, expires: this.now() + 9e5, record: record25, seen: /* @__PURE__ */ new Set(), valid: () => this.entries.get(loadId) === entry && writer?.loadGeneration?.() === epoch && this.now() <= entry.expires };
     this.entries.set(loadId, entry);
     return () => {
       if (this.entries.get(loadId) === entry) this.entries.delete(loadId);
     };
   }
   report(input, owner2) {
-    const parsed = ThreadLoadReportSchema.safeParse(input);
+    let parsed;
+    try {
+      parsed = input?.version === 2 ? { success: true, data: parseThreadLoadReportV2(input) } : ThreadLoadReportSchema.safeParse(input);
+    } catch {
+      parsed = { success: false };
+    }
     if (!parsed.success) return { accepted: false };
     const { load_id, thread_id, samples } = parsed.data;
     const entry = this.entries.get(load_id);
-    if (!entry || entry.threadId !== thread_id || entry.owner !== owner2 || entry.expires < this.now()) return { accepted: false };
+    if (!entry || entry.threadId !== thread_id || entry.owner !== owner2 || entry.expires < this.now() || entry.valid && !entry.valid()) return { accepted: false };
+    if (entry.accept) {
+      entry.accept(samples, parsed.data.client_class, parsed.data.terminal);
+      return { accepted: true };
+    }
     for (const sample of samples) if (!entry.seen.has(sample.phase)) {
       entry.seen.add(sample.phase);
       try {
@@ -30618,6 +30818,8 @@ var ThreadOpenQuerySchema = z9.object({
   range_resume_version: z9.literal("1").transform(() => 1).optional(),
   range_resume_token: z9.string().regex(/^[A-Za-z0-9_-]{43}$/).optional(),
   load_id: z9.string().uuid().optional(),
+  // 恢复关联仍保留，只有首屏采样可显式关闭。
+  load_trace: z9.literal("false").transform(() => false).optional(),
   include_execution: z9.literal("true").transform(() => true).optional(),
   include_message_times: z9.literal("true").transform(() => true).optional(),
   include_async_questions: z9.literal("true").transform(() => true).optional(),
@@ -31738,6 +31940,7 @@ function createThreadOpenSseProjection(rawQuery, options = {}) {
       ...query2.range_resume_version ? { rangeResumeVersion: 1 } : {},
       ...query2.range_resume_token ? { rangeResumeToken: query2.range_resume_token } : {},
       ...query2.load_id ? { loadId: query2.load_id } : {},
+      ...query2.load_trace === false ? { loadTrace: false } : {},
       viewVersion: THREAD_VIEW_VERSION,
       ...query2.include_async_questions ? { includeAsyncQuestions: true } : {},
       ...query2.include_read_receipts ? { includeReadReceipts: true } : {},
@@ -32772,7 +32975,7 @@ async function dispatchRestRoute(request2, dependencies) {
     }
   }
   if (route === "POST /api/v1/thread/load/report") {
-    const body = ThreadLoadReportSchema.parse(request2.body);
+    const body = request2.body?.version === 2 ? ThreadLoadReportV2Schema.parse(request2.body) : ThreadLoadReportSchema.parse(request2.body);
     const result = await daemonClient.request("thread/load/report", body, {
       ...daemonRequestOptions(5e3, request2.signal),
       ...request2.authenticatedMessageSubmissionScope !== void 0 ? { authenticatedMessageSubmissionScope: request2.authenticatedMessageSubmissionScope } : {}
@@ -43068,8 +43271,8 @@ function createRelayAttachmentDataLink(options) {
     const child = { permit, lease: null, ws: null, receiver: null, closed: false, paired: false, ready: false, opening: null, cleanup: null, unregister: null };
     children.set(permit.transfer_id, child);
     const registrationStarted = Date.now();
-    const timing = () => ({ attach_remaining_ms: permit.attach_expires_at - Date.now(), transfer_remaining_ms: permit.expires_at - Date.now(), registration_elapsed_ms: Date.now() - registrationStarted });
-    recordAttachmentDiagnostic(options.diagnostic, { phase: "file.register", reason: "started", ...timing() });
+    const timing2 = () => ({ attach_remaining_ms: permit.attach_expires_at - Date.now(), transfer_remaining_ms: permit.expires_at - Date.now(), registration_elapsed_ms: Date.now() - registrationStarted });
+    recordAttachmentDiagnostic(options.diagnostic, { phase: "file.register", reason: "started", ...timing2() });
     try {
       const reply = await options.control.requestFileControl("file.register", {
         version: 1,
@@ -43081,7 +43284,7 @@ function createRelayAttachmentDataLink(options) {
         max_wire_bytes: attachmentTransferWireBudget(permit.context.byte_size)
       });
       if (reply.code !== 0) {
-        recordAttachmentDiagnostic(options.diagnostic, { phase: "file.register", reason: "failed", code: reply.code, ...timing() });
+        recordAttachmentDiagnostic(options.diagnostic, { phase: "file.register", reason: "failed", code: reply.code, ...timing2() });
         const error2 = unavailable7();
         error2.cause = { stage: "file.register", relayCode: reply.code };
         throw error2;
@@ -46646,7 +46849,7 @@ var RuntimeDesktopIngress = class {
   resetMethodValidity() {
     this.ipcMethodInvalidatedThreads.clear();
   }
-  async process(frame, ownClientId = this.ports.ipc()?.getClientId?.() ?? null, receivedIpcGeneration = this.ports.ipcConnectionGeneration(), timing, readDiagnostic) {
+  async process(frame, ownClientId = this.ports.ipc()?.getClientId?.() ?? null, receivedIpcGeneration = this.ports.ipcConnectionGeneration(), timing2, readDiagnostic) {
     this.ports.writeDebug({
       component: "daemon",
       channel: "ipc",
@@ -46656,7 +46859,7 @@ var RuntimeDesktopIngress = class {
       attributes: {
         type: frame.type,
         ...typeof frame.method === "string" ? { method: frame.method } : {},
-        ...timing
+        ...timing2
       }
     });
     this.ports.writeRawDebug({
@@ -46688,6 +46891,9 @@ var RuntimeDesktopIngress = class {
     }
     const status2 = objectRecord(frame.params);
     const methodThreadId = extractThreadIdFromIpcFrame(frame);
+    if (!this.ports.stopping() && receivedIpcGeneration === this.ports.ipcConnectionGeneration() && this.ports.desktopIpcState() === "ready" && ownClientId && frame.type === "broadcast" && frame.sourceClientId && frame.sourceClientId !== ownClientId && status2.hostId === "local" && methodThreadId && (frame.method === "thread-stream-following-status-requested" || frame.method === "thread-stream-following-changed" && status2.following === true)) {
+      this.ports.discoverThread(methodThreadId);
+    }
     if (frame.method === "thread-stream-state-changed" && methodThreadId && this.ipcMethodInvalidatedThreads.has(methodThreadId) && objectRecord(status2.change).type !== "snapshot") {
       if (readDiagnostic) readDiagnostic.reason = "baseline_required";
       return;
@@ -47343,19 +47549,19 @@ var DesktopIpcClient = class {
     this.events.on("requestDiagnostic", listener);
     return () => this.events.off("requestDiagnostic", listener);
   }
-  emitRequestDiagnostic(timing, phase, outcome) {
+  emitRequestDiagnostic(timing2, phase, outcome) {
     this.events.emit("requestDiagnostic", {
-      requestId: timing.requestId,
-      method: timing.method,
-      threadId: timing.threadId,
+      requestId: timing2.requestId,
+      method: timing2.method,
+      threadId: timing2.threadId,
       phase,
       outcome,
-      durationMs: Math.max(0, Math.floor(performance.now() - timing.startedAt))
+      durationMs: Math.max(0, Math.floor(performance.now() - timing2.startedAt))
     });
   }
   pruneTimedOutRequests() {
-    for (const [id5, timing] of this.timedOutRequests) {
-      if (performance.now() - timing.startedAt > 12e4) this.timedOutRequests.delete(id5);
+    for (const [id5, timing2] of this.timedOutRequests) {
+      if (performance.now() - timing2.startedAt > 12e4) this.timedOutRequests.delete(id5);
     }
     while (this.timedOutRequests.size > 128) this.timedOutRequests.delete(this.timedOutRequests.keys().next().value);
   }
@@ -47492,20 +47698,20 @@ var DesktopIpcClient = class {
     this.pruneTimedOutRequests();
     const localParams = params && typeof params === "object" ? params : {};
     const threadId2 = typeof localParams.threadId === "string" ? localParams.threadId : typeof localParams.conversationId === "string" ? localParams.conversationId : void 0;
-    const timing = { requestId, method: method2, threadId: threadId2, startedAt: performance.now() };
+    const timing2 = { requestId, method: method2, threadId: threadId2, startedAt: performance.now() };
     const responsePromise = new Promise((resolve5, reject3) => {
       const timer = setTimeout(() => {
         this.pending.delete(requestId);
-        this.timedOutRequests.set(requestId, timing);
+        this.timedOutRequests.set(requestId, timing2);
         this.pruneTimedOutRequests();
-        this.emitRequestDiagnostic(timing, "timeout", "unknown");
+        this.emitRequestDiagnostic(timing2, "timeout", "unknown");
         reject3(new NiumaError("UNKNOWN_RESULT", `IPC \u8BF7\u6C42\u8D85\u65F6: ${method2}`, { method: method2 }));
       }, options.timeoutMs ?? this.requestTimeoutMs);
-      this.pending.set(requestId, { timer, resolve: resolve5, reject: reject3, timing });
+      this.pending.set(requestId, { timer, resolve: resolve5, reject: reject3, timing: timing2 });
     });
     try {
       await this.write(frame);
-      this.emitRequestDiagnostic(timing, "sent", "pending");
+      this.emitRequestDiagnostic(timing2, "sent", "pending");
     } catch (error2) {
       this.clearPending(requestId);
       throw error2 instanceof Error ? new NiumaError("IPC_NOT_INITIALIZED", error2.message) : new NiumaError("IPC_NOT_INITIALIZED", String(error2));
@@ -47604,10 +47810,10 @@ var DesktopIpcClient = class {
     this.pruneTimedOutRequests();
     const outcome = frame.resultType === "error" ? "error" : "success";
     if (!pending) {
-      const timing = this.timedOutRequests.get(requestId);
-      if (timing) {
+      const timing2 = this.timedOutRequests.get(requestId);
+      if (timing2) {
         this.timedOutRequests.delete(requestId);
-        this.emitRequestDiagnostic(timing, "late_response", outcome);
+        this.emitRequestDiagnostic(timing2, "late_response", outcome);
       }
       return;
     }
@@ -56320,15 +56526,46 @@ function createHistoryHandlers(ports) {
       if (negotiated && (!handoffScope || !scope || scope.bindingId !== handoffScope.bindingId)) {
         throw new HttpApiError(200, 200004, "\u6B63\u6587\u4EA4\u63A5\u9700\u8981\u8BA4\u8BC1\u4F1A\u8BDD");
       }
+      const loadStartedAt = performance.now();
+      const loadAttempt = params.loadTrace === false ? null : ports.threadLoadReports().begin?.({ loadId: params.loadId, threadId: threadId2, owner: scope ? `binding:${scope.bindingId.toLowerCase()}` : "local", transport: scope?.transport ?? "local", nowMs: Date.now() });
+      const loadElapsed = () => Math.max(0, Math.min(9e5, Math.round(performance.now() - loadStartedAt)));
+      let loadFailurePhase = "open_received";
+      const failOpen = (error2) => {
+        if (!options.signal?.aborted && normalizeHttpError(error2).httpStatus === 200) loadAttempt?.finish("failed", { terminal_phase: loadFailurePhase, reason: "open_rejected" });
+      };
       if (negotiated && typeof params.handoffTicket === "string") {
-        if (options.signal?.aborted || socket.destroyed || socket.writableEnded) return STREAMING_RESPONSE;
-        const consumer = ports.connectionHandoff().claim(
-          handoffScope,
-          params.handoffDescriptor,
-          params.handoffTicket,
-          { emit: (frame) => socket.write(`${JSON.stringify(successEnvelope(frame))}
-`), onClose: () => socket.end() }
-        );
+        if (options.signal?.aborted || socket.destroyed || socket.writableEnded) {
+          loadAttempt?.close();
+          return STREAMING_RESPONSE;
+        }
+        let consumer;
+        try {
+          consumer = ports.connectionHandoff().claim(
+            handoffScope,
+            params.handoffDescriptor,
+            params.handoffTicket,
+            { emit: (frame) => {
+              socket.write(`${JSON.stringify(successEnvelope(frame))}
+`);
+              if (frame.type === "thread_view_snapshot") {
+                loadFailurePhase = "shell_sent";
+                loadAttempt?.markDaemon("shell_sent", loadElapsed());
+              }
+              const view = frame.data;
+              if (view?.availability?.state === "ready") {
+                loadFailurePhase = "history_sent";
+                loadAttempt?.markDaemon("history_sent", loadElapsed());
+              }
+            }, onClose: () => {
+              loadAttempt?.close();
+              socket.end();
+            } }
+          );
+        } catch (error2) {
+          failOpen(error2);
+          loadAttempt?.close();
+          throw error2;
+        }
         let recoveryClosed = false;
         let unregisterRecovery2 = () => {
         };
@@ -56341,12 +56578,14 @@ function createHistoryHandlers(ports) {
           }) : () => {
           };
         } catch (error2) {
+          loadAttempt?.close();
           consumer.close();
           throw error2;
         }
         let unregisterArchive2 = () => {
         };
         const close2 = () => {
+          loadAttempt?.close();
           unregisterArchive2();
           recoveryClosed = true;
           unregisterRecovery2();
@@ -56373,7 +56612,6 @@ function createHistoryHandlers(ports) {
 `);
         return STREAMING_RESPONSE;
       }
-      const loadStartedAt = performance.now();
       let loadTrace = null;
       let loadLeaseId = null;
       let unregisterLoad = () => {
@@ -56383,7 +56621,9 @@ function createHistoryHandlers(ports) {
       const pendingLoad = [];
       const loadSeen = /* @__PURE__ */ new Set();
       const recordLoad = (phase, clock = "daemon", elapsed = Math.round(performance.now() - loadStartedAt), occurredAt4 = clock === "daemon" ? Date.now() : void 0) => {
-        if (typeof params.loadId !== "string" || elapsed < 0 || elapsed > 9e5) return;
+        if (clock === "daemon" && ["open_received", "identity_ready", "lease_acquired", "shell_sent", "history_sent"].includes(phase)) loadFailurePhase = phase;
+        if (params.loadTrace === false || typeof params.loadId !== "string" || elapsed < 0 || elapsed > 9e5) return;
+        if (clock === "daemon") loadAttempt?.markDaemon(phase, elapsed, occurredAt4);
         if (!loadLeaseId) {
           if (pendingLoad.length < 8) pendingLoad.push({ phase, elapsed, occurredAt: occurredAt4 });
           return;
@@ -56472,6 +56712,7 @@ function createHistoryHandlers(ports) {
           readReceiptTimer = null;
         }
         recordLoad("stream_closed");
+        loadAttempt?.close();
         unregisterLoad();
         unregisterRecovery();
         closed = true;
@@ -56508,6 +56749,7 @@ function createHistoryHandlers(ports) {
       const close = () => {
         if (physicalClosed) return;
         physicalClosed = true;
+        loadAttempt?.close();
         unregisterRecovery();
         options.signal?.removeEventListener("abort", close);
         publisher?.close();
@@ -56524,7 +56766,14 @@ function createHistoryHandlers(ports) {
         return STREAMING_RESPONSE;
       }
       if (!ports.store().getThread(threadId2, { tailCount: 0 })) {
-        await ports.verifyThreadForOpen(threadId2);
+        try {
+          await ports.verifyThreadForOpen(threadId2);
+        } catch (error2) {
+          failOpen(error2);
+          loadAttempt?.close();
+          detachClose();
+          throw error2;
+        }
       }
       if (closed || socketIsClosed()) {
         closed = true;
@@ -56573,13 +56822,15 @@ function createHistoryHandlers(ports) {
         }
         for (const sample of pendingLoad) recordLoad(sample.phase, "daemon", sample.elapsed, sample.occurredAt);
         pendingLoad.length = 0;
+        if (loadLeaseId && loadTrace) loadAttempt?.attachLease(loadLeaseId, loadTrace.traceId);
         recordLoad("lease_acquired");
         try {
-          if (loadLeaseId && loadTrace) unregisterLoad = ports.threadLoadReports().register(
+          if (loadAttempt && loadLeaseId && loadTrace) unregisterLoad = ports.threadLoadReports().register(
             params.loadId,
             threadId2,
             scope ? `binding:${scope.bindingId.toLowerCase()}` : "local",
-            (sample) => recordLoad(sample.phase, "browser", sample.elapsed_ms, sample.occurred_at_ms)
+            (sample) => recordLoad(sample.phase, "browser", sample.elapsed_ms, sample.occurred_at_ms),
+            loadAttempt
           );
         } catch {
         }
@@ -56693,6 +56944,7 @@ function createHistoryHandlers(ports) {
         ports.requestThreadAuthorityRecovery(threadId2, true);
         ports.history().onHistoryLeaseStateChanged(threadId2, ports.activeThreadFollowerCoordinator()?.leaseKindsFor(threadId2) ?? []);
         unsubscribeHistoryWindow = historyWindow.subscribe(() => {
+          if (historyWindow?.initialWindowState === "failed") loadAttempt?.finish("failed", { terminal_phase: "shell_sent", reason: "history_failed" });
           if (rangeClaim && historyWindow?.initialWindowState === "failed") {
             socket.write(`${JSON.stringify(errorEnvelope(new NiumaError("HISTORY_SNAPSHOT_EXPIRED", "\u5386\u53F2\u6062\u590D\u8303\u56F4\u4E0D\u53EF\u7528\u6216\u5DF2\u8FC7\u671F")))}
 `);
@@ -56767,6 +57019,7 @@ function createHistoryHandlers(ports) {
 `);
         }
       } catch (error2) {
+        failOpen(error2);
         try {
           const sites = [
             ["historySourceAssertion", "Object.sourceCurrent"],
@@ -56838,20 +57091,20 @@ function text10(value) {
     return false;
   }
 }
-function object9(value, keys3) {
+function object10(value, keys3) {
   if (!value || typeof value !== "object" || Array.isArray(value) || ![Object.prototype, null].includes(Object.getPrototypeOf(value))) return fail16("invalid");
   const own = Reflect.ownKeys(value);
   if (own.length !== keys3.length || !own.every((key) => typeof key === "string" && keys3.includes(key) && "value" in Object.getOwnPropertyDescriptor(value, key))) return fail16("invalid");
   return value;
 }
 function parseAsyncQuestionBatch(value) {
-  const raw = object9(value, ["thread_id", "group_id", "revision", "idempotency_key", "question_ids", "answers"]);
+  const raw = object10(value, ["thread_id", "group_id", "revision", "idempotency_key", "question_ids", "answers"]);
   if (!id3(raw.thread_id) || !id3(raw.group_id) || !id3(raw.idempotency_key) || !Number.isSafeInteger(raw.revision) || raw.revision < 0 || !Array.isArray(raw.question_ids) || !raw.question_ids.length || raw.question_ids.length > 256 || !Array.isArray(raw.answers) || raw.answers.length > raw.question_ids.length) return fail16("invalid");
   const questionIds = Array.from(raw.question_ids);
   if (!questionIds.every(id3) || new Set(questionIds).size !== questionIds.length) return fail16("invalid");
   const seen = /* @__PURE__ */ new Set();
   const answers = Array.from(raw.answers, (value2) => {
-    const answer = object9(value2, ["question_id", "title", "answer"]);
+    const answer = object10(value2, ["question_id", "title", "answer"]);
     if (!id3(answer.question_id) || !questionIds.includes(answer.question_id) || seen.has(answer.question_id) || !text10(answer.title) || !text10(answer.answer)) return fail16("invalid");
     seen.add(answer.question_id);
     return { question_id: answer.question_id, title: answer.title, answer: answer.answer };
@@ -59640,10 +59893,10 @@ var ThreadHistoryWindowLoader = class {
       sourceRevision: 0
     };
     for (let attempt = 0; attempt < 2; attempt++) {
-      const timing = await this.timestampVersion(turn, signal);
+      const timing2 = await this.timestampVersion(turn, signal);
       this.assertSource(epoch);
       signal.throwIfAborted();
-      const versionKey = JSON.stringify([epoch, description.contentVersion, timing]);
+      const versionKey = JSON.stringify([epoch, description.contentVersion, timing2]);
       let cached = this.turns.get(identity6);
       if (cached?.current?.version === versionKey) {
         if (description.sourceRevision >= cached.sourceRevision && cached.nativeOrder !== description.nativeOrder) {
@@ -59660,7 +59913,7 @@ var ThreadHistoryWindowLoader = class {
       this.assertSource(epoch);
       signal.throwIfAborted();
       if (enriched.turnId !== turn.id) throw new RangeError("\u7A97\u53E3\u65F6\u95F4\u8865\u9F50 Turn \u8EAB\u4EFD\u4E0D\u5339\u914D");
-      if (await this.timestampVersion(turn, signal) !== timing) continue;
+      if (await this.timestampVersion(turn, signal) !== timing2) continue;
       this.assertSource(epoch);
       signal.throwIfAborted();
       const freeze = (value) => {
@@ -59718,11 +59971,11 @@ var ThreadHistoryWindowLoader = class {
     const epoch = this.sourceEpoch;
     this.currentProtection.addTurnIds([turn.id]);
     const description = this.reader.describeTurn?.(turn) ?? { contentVersion: createHash26("sha256").update(JSON.stringify(turn)).digest("hex") };
-    const timing = await this.timestampVersion(turn, signal);
+    const timing2 = await this.timestampVersion(turn, signal);
     this.assertSource(epoch);
     signal.throwIfAborted();
     const cached = this.turns.get(JSON.stringify([this.currentThreadId, turn.id]));
-    if (cached?.current?.version === JSON.stringify([epoch, description.contentVersion, timing])) {
+    if (cached?.current?.version === JSON.stringify([epoch, description.contentVersion, timing2])) {
       this.holdVersion(this.currentProtection, cached.current);
       return cached.current.projection.displayItemCount;
     }
@@ -60942,17 +61195,17 @@ var AppServerThreadViewAdapter = class {
       lastError: null
     }).status;
     const terminalStatus = failed || aborted || status2 === "completed" ? lifecycleStatus : "completed";
-    const timing = context.getTurnLifecycle?.(turnId);
+    const timing2 = context.getTurnLifecycle?.(turnId);
     return [{
       type: "ThreadStatusChanged",
       thread_id: context.threadId,
       status: terminalStatus,
       turn_id: turnId,
       terminal_item_state: terminalStatus === "error" ? "failed" : "completed",
-      ...timing ? { process_lifecycle: {
-        startedAt: lifecycleTime(timing.startedAt),
-        endedAt: lifecycleTime(timing.endedAt),
-        outcome: timing.outcome
+      ...timing2 ? { process_lifecycle: {
+        startedAt: lifecycleTime(timing2.startedAt),
+        endedAt: lifecycleTime(timing2.endedAt),
+        outcome: timing2.outcome
       } } : {},
       last_error: terminalStatus === "error" ? {
         code: 900001,
@@ -61207,10 +61460,10 @@ var ThreadHistoryWindowProjection = class {
     const enriched = this.options.enrichTimeline ? await this.options.enrichTimeline(sources.map((source2) => source2.timeline), startedAt) : this.timestamps.enrichTimelineFromReplay(sources.map((source2) => source2.timeline), startedAt, replay);
     const timingById = new Map(sources.map((source2, index) => [source2.id, enriched[index]]));
     const items = projected.items.map((item) => {
-      const timing = timingById.get(item.id);
+      const timing2 = timingById.get(item.id);
       const fact = item.process_fact;
-      if (!timing || !fact) return item;
-      const merged = mergeThreadHistoryTimelineLifecycle(timing, {
+      if (!timing2 || !fact) return item;
+      const merged = mergeThreadHistoryTimelineLifecycle(timing2, {
         ...fact.startedAt !== null ? { turnStartedAt: fact.startedAt } : {},
         ...fact.endedAt !== null ? { turnEndedAt: fact.endedAt } : {},
         ...fact.durationMs != null ? { turnDurationMs: fact.durationMs } : {},
@@ -62059,7 +62312,7 @@ function readStateDiagnostic(before, after, candidate = after.confirmed) {
     sameCycle: candidate ? candidate.cycle === after.cycle : null
   };
 }
-function object10(value) {
+function object11(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 function field(value, present, count) {
@@ -62069,15 +62322,15 @@ function field(value, present, count) {
 }
 function unreadFrameDiagnostic(frame) {
   if (frame.method !== "thread-stream-state-changed") return null;
-  const params = object10(frame.params), change = object10(params.change);
+  const params = object11(frame.params), change = object11(params.change);
   const kind = change.type === "snapshot" ? "snapshot" : change.type === "patches" ? "patch" : "invalid";
-  const values = kind === "snapshot" ? object10(change.conversationState) : {};
+  const values = kind === "snapshot" ? object11(change.conversationState) : {};
   let unread = field(values.hasUnreadTurn, Object.hasOwn(values, "hasUnreadTurn"), false);
   let count = field(values.unreadMessageCount, Object.hasOwn(values, "unreadMessageCount"), true);
   let countValue = values.unreadMessageCount;
   if (kind === "patch") {
     for (const value of Array.isArray(change.patches) ? change.patches : []) {
-      const patch = object10(value), path54 = Array.isArray(patch.path) ? patch.path : [];
+      const patch = object11(value), path54 = Array.isArray(patch.path) ? patch.path : [];
       const name2 = path54.length === 1 ? path54[0] : path54.length === 2 && path54[0] === "conversationState" ? path54[1] : null;
       if (name2 !== "hasUnreadTurn" && name2 !== "unreadMessageCount") continue;
       const state = patch.op === "remove" ? "removed" : ["add", "replace"].includes(String(patch.op)) ? field(patch.value, Object.hasOwn(patch, "value"), name2 === "unreadMessageCount") : "invalid";
@@ -62119,10 +62372,10 @@ var RuntimeIngressDispatch = class {
   }
   ports;
   /** 单帧入站与最终结果成对记录；原始字段与业务结果分开，拒绝帧同样留证。 */
-  async handleIpcFrame(frame, ownClientId = this.ports.desktopSession().ipcValue?.getClientId?.() ?? null, receivedIpcGeneration = this.ports.desktopSession().ipcConnectionGenerationValue, timing) {
+  async handleIpcFrame(frame, ownClientId = this.ports.desktopSession().ipcValue?.getClientId?.() ?? null, receivedIpcGeneration = this.ports.desktopSession().ipcConnectionGenerationValue, timing2) {
     const attributes = this.ports.options().debugLogger ? unreadFrameDiagnostic(frame) : null;
     const threadId2 = attributes ? extractThreadIdFromIpcFrame(frame) : null;
-    if (!attributes || !threadId2) return this.ports.desktopIngress().process(frame, ownClientId, receivedIpcGeneration, timing);
+    if (!attributes || !threadId2) return this.ports.desktopIngress().process(frame, ownClientId, receivedIpcGeneration, timing2);
     const before = this.ports.catalog().storeValue.getThread(threadId2, { tailCount: 0 })?.unread;
     const diagnostic = { reason: "processed" };
     const metadata = { ...attributes, sequence: this.ports.diagnostics().threadReadDiagnosticSequenceValue++, generation: receivedIpcGeneration, currentGeneration: this.ports.desktopSession().ipcConnectionGenerationValue };
@@ -62135,7 +62388,7 @@ var RuntimeIngressDispatch = class {
       }
     });
     try {
-      await this.ports.desktopIngress().process(frame, ownClientId, receivedIpcGeneration, timing, diagnostic);
+      await this.ports.desktopIngress().process(frame, ownClientId, receivedIpcGeneration, timing2, diagnostic);
     } catch (error2) {
       diagnostic.reason = "processing_failed";
       throw error2;
@@ -63863,11 +64116,11 @@ var RuntimeProjectionContext = class {
       } : null),
       enrichTimelineItemTiming: (item) => this.ports.timelinePublication().enrichTimelineItemTiming(item, timelineItems),
       getTurnLifecycle: (turnId) => {
-        const timing = this.ports.timelinePublication().turnTiming(threadId2, turnId);
-        return timing ? {
-          startedAt: timing.startedAt,
-          endedAt: timing.endedAt ?? null,
-          outcome: timing.outcome ?? null
+        const timing2 = this.ports.timelinePublication().turnTiming(threadId2, turnId);
+        return timing2 ? {
+          startedAt: timing2.startedAt,
+          endedAt: timing2.endedAt ?? null,
+          outcome: timing2.outcome ?? null
         } : null;
       },
       resolveKnownLocalImage: (sourcePath, itemId, partIndex) => this.ports.resolveThreadViewImage(threadId2, sourcePath, () => this.ports.isCurrentAppServerAsyncFence(threadId2, fence), itemId, partIndex)
@@ -64396,7 +64649,7 @@ var DesktopThreadSettingsTracker = class {
 
 // apps/desktop/src/daemon/active-thread-follower-coordinator.ts
 init_session_history_file();
-var ACTIVE_THREAD_SCAN_INTERVAL_MS = 1e4;
+var ACTIVE_THREAD_SCAN_INTERVAL_MS = 6e4;
 var ACTIVE_THREAD_READ_CONCURRENCY = 4;
 var ACTIVE_FOLLOWER_SNAPSHOT_TIMEOUT_MS = 12e3;
 var ACTIVE_FOLLOWER_RETRY_DELAYS_MS = [1e3, 2e3, 5e3, 1e4, 3e4];
@@ -71378,7 +71631,7 @@ var RuntimeThreadStateCoordination = class {
     return token3;
   }
   /** 仅供已核验的同轮终态使用；同时收敛列表与详情，不伪造新的完成通知。 */
-  applyRecoveredTerminal(threadId2, turnId, outcome, occurredAt4, message, timing) {
+  applyRecoveredTerminal(threadId2, turnId, outcome, occurredAt4, message, timing2) {
     const previous = this.ports.catalog().storeValue.getThread(threadId2, { tailCount: 0 });
     const mutation = this.ports.catalog().storeValue.applyActivitySignal({
       type: "snapshot",
@@ -71398,7 +71651,7 @@ var RuntimeThreadStateCoordination = class {
         turn_id: turnId,
         status: outcome === "aborted" ? "idle" : outcome === "failed" ? "error" : "completed",
         terminal_item_state: outcome === "failed" ? "failed" : "completed",
-        process_lifecycle: { startedAt: timing?.startedAt ?? null, endedAt: timing?.endedAt ?? null, outcome },
+        process_lifecycle: { startedAt: timing2?.startedAt ?? null, endedAt: timing2?.endedAt ?? null, outcome },
         last_error: outcome === "failed" && message ? { code: 900001, message, occurred_at: occurredAt4, turn_id: turnId } : null
       },
       { type: "ThreadActivityChanged", thread_id: threadId2, turn_id: turnId, activity: null },
@@ -71637,15 +71890,15 @@ var RuntimeTimelinePublication = class {
     if (!item.turnId) {
       return item;
     }
-    const timing = this.liveTurnTimings.get(this.turnTimingKey(item.threadId, item.turnId));
-    if (!timing) {
+    const timing2 = this.liveTurnTimings.get(this.turnTimingKey(item.threadId, item.turnId));
+    if (!timing2) {
       return item;
     }
     return {
       ...item,
-      ...item.turnStartedAt === void 0 ? { turnStartedAt: timing.startedAt } : {},
-      ...item.turnEndedAt === void 0 && timing.endedAt !== void 0 ? { turnEndedAt: timing.endedAt } : {},
-      ...item.turnOutcome === void 0 && timing.outcome !== void 0 ? { turnOutcome: timing.outcome } : {}
+      ...item.turnStartedAt === void 0 ? { turnStartedAt: timing2.startedAt } : {},
+      ...item.turnEndedAt === void 0 && timing2.endedAt !== void 0 ? { turnEndedAt: timing2.endedAt } : {},
+      ...item.turnOutcome === void 0 && timing2.outcome !== void 0 ? { turnOutcome: timing2.outcome } : {}
     };
   }
   enrichTimelineItemTiming(item, historyItems = []) {
@@ -71665,9 +71918,9 @@ var RuntimeTimelinePublication = class {
   turnTimingKey(threadId2, turnId) {
     return `${threadId2}:${turnId}`;
   }
-  setLiveTurnTiming(key, timing) {
+  setLiveTurnTiming(key, timing2) {
     this.liveTurnTimings.delete(key);
-    this.liveTurnTimings.set(key, timing);
+    this.liveTurnTimings.set(key, timing2);
     while (this.liveTurnTimings.size > LIVE_TURN_TIMING_LIMIT) {
       const oldestKey = this.liveTurnTimings.keys().next().value;
       if (typeof oldestKey !== "string") break;
@@ -79790,8 +80043,7 @@ var RuntimeNativeAdmission = class {
     else if (kind === "ordinary") this.hidden.delete(thread4.id);
     const old = this.entries.get(thread4.id);
     this.failures.delete(thread4.id);
-    if (old && old.kind === kind) return old.token;
-    const token3 = { threadId: thread4.id, generation: ++this.sequence, executionGeneration };
+    const token3 = old && old.kind === kind ? old.token : { threadId: thread4.id, generation: ++this.sequence, executionGeneration };
     this.entries.set(thread4.id, { token: token3, kind });
     try {
       if (kind !== previous) this.ports.onChange?.(thread4.id, previous, kind);
@@ -79801,7 +80053,7 @@ var RuntimeNativeAdmission = class {
     }
     const pending = this.jobs.get(thread4.id);
     if (pending) {
-      this.finishWait(pending, kind);
+      this.finishWait(pending, kind, thread4, token3);
       if (!pending.started) {
         this.removeQueued(pending);
         this.removeJob(pending);
@@ -79809,13 +80061,20 @@ var RuntimeNativeAdmission = class {
     }
     return token3;
   }
-  ensure(id5, executionGeneration) {
-    if (executionGeneration !== this.execution) return Promise.resolve("unknown");
+  async ensure(id5, executionGeneration) {
+    return (await this.query(id5, executionGeneration, false)).kind;
+  }
+  /** 目录缺项时请求摘要，与未知准入共用单飞、退避和物理槽。 */
+  ensureSummary(id5, executionGeneration) {
+    return this.query(id5, executionGeneration, true);
+  }
+  query(id5, executionGeneration, needSummary) {
+    if (executionGeneration !== this.execution) return Promise.resolve({ kind: "unknown" });
     const known = this.kind(id5);
-    if (known !== "unknown") return Promise.resolve(known);
+    if (known !== "unknown" && (!needSummary || known === "subagent")) return Promise.resolve({ kind: known });
     const pending = this.jobs.get(id5);
-    if (pending) return pending.execution === this.execution ? pending.promise : Promise.resolve("unknown");
-    if ((this.failures.get(id5) ?? 0) > this.now() || this.queue.length >= 64) return Promise.resolve("unknown");
+    if (pending) return pending.execution === this.execution ? pending.promise : Promise.resolve({ kind: "unknown" });
+    if ((this.failures.get(id5) ?? 0) > this.now() || this.queue.length >= 64) return Promise.resolve({ kind: "unknown" });
     let resolve5;
     const promise = new Promise((done) => {
       resolve5 = done;
@@ -79872,11 +80131,11 @@ var RuntimeNativeAdmission = class {
   removeJob(job) {
     if (this.jobs.get(job.id) === job) this.jobs.delete(job.id);
   }
-  finishWait(job, kind) {
+  finishWait(job, kind, summary, token3) {
     if (job.settled) return;
     job.settled = true;
     job.cancel();
-    job.resolve(kind);
+    job.resolve({ kind, ...summary ? { summary, token: token3 } : {} });
   }
   fail(job) {
     if (job.execution === this.execution) {
@@ -79910,7 +80169,7 @@ var RuntimeNativeAdmission = class {
         this.observe(result.thread, job.execution);
         const kind = this.kind(job.id);
         if (kind === "unknown") this.fail(job);
-        this.finishWait(job, kind);
+        this.finishWait(job, kind, result.thread, this.token(job.id));
       }).catch(() => {
         if (!job.settled) {
           this.fail(job);
@@ -80273,6 +80532,7 @@ var DEBUG_EVENTS = [
   "ipc_recovery",
   "ipc_forwarding_flow",
   "notification_delivery",
+  "ipc_thread_discovery",
   "startup_timing",
   "thread_settings_cache",
   "thread_list_cache",
@@ -80506,6 +80766,7 @@ var SAFE_ATTRIBUTE_KEYS = {
     "inFlight"
   ],
   // 启动性能仅保留固定阶段耗时和汇总计数，禁止记录路径、会话或异常原文。
+  ipc_thread_discovery: ["durationMs"],
   startup_timing: [
     "durationMs",
     "threadCount",
@@ -81055,6 +81316,7 @@ var SAFE_PHASES = {
     "dropped_busy",
     "deadline_expired"
   ],
+  ipc_thread_discovery: ["received", "ignored", "deduplicated", "capacity", "read_completed", "rejected", "stale", "published", "failed"],
   startup_timing: [
     "app_server_initialized",
     "thread_baseline_scanned",
@@ -81748,19 +82010,19 @@ function withoutPersistentImageBytes(value, key = "", seen = /* @__PURE__ */ new
   if (seen.has(value)) return "[circular]";
   seen.add(value);
   try {
-    const object11 = value;
-    if (object11.type === "Buffer" && Array.isArray(object11.data)) {
-      return { type: "binary_omitted", byteSize: object11.data.length };
+    const object12 = value;
+    if (object12.type === "Buffer" && Array.isArray(object12.data)) {
+      return { type: "binary_omitted", byteSize: object12.data.length };
     }
-    if (object11.event === "app_server_stdout") {
-      const payload = object11.rawPayload;
-      const metadata = Object.fromEntries(Object.entries(object11).filter(([name2]) => name2 !== "rawPayload").map(([name2, entry]) => [name2, withoutPersistentImageBytes(entry, name2, seen)]));
+    if (object12.event === "app_server_stdout") {
+      const payload = object12.rawPayload;
+      const metadata = Object.fromEntries(Object.entries(object12).filter(([name2]) => name2 !== "rawPayload").map(([name2, entry]) => [name2, withoutPersistentImageBytes(entry, name2, seen)]));
       return { ...metadata, rawPayload: { type: "stdout_fragment", bytes: typeof payload?.bytes === "number" ? payload.bytes : typeof payload?.fragment === "string" ? Buffer.byteLength(payload.fragment) : 0 } };
     }
     if (Array.isArray(value)) return value.map((entry) => withoutPersistentImageBytes(entry, key, seen));
-    return Object.fromEntries(Object.entries(object11).map(([name2, entry]) => [
+    return Object.fromEntries(Object.entries(object12).map(([name2, entry]) => [
       name2,
-      withoutPersistentImageBytes(entry, object11.type === "image" && name2 === "data" ? "base64" : name2, seen)
+      withoutPersistentImageBytes(entry, object12.type === "image" && name2 === "data" ? "base64" : name2, seen)
     ]));
   } finally {
     seen.delete(value);
@@ -82854,6 +83116,7 @@ var NiumaDaemonRuntime = class {
   }
   desktopTrackers = new RuntimeDesktopIngressTrackers();
   desktopIngress = new RuntimeDesktopIngress({
+    discoverThread: (id5) => this.ipcThreadDiscovery.discover(id5),
     nativeAdmission: () => this.nativeAdmission,
     ensureNativeAdmission: (id5) => this.ensureNativeAdmission(id5),
     requestReadFileRefresh: () => this.followerCoordination.desktopReadStateFileValue?.requestRefresh(),
@@ -83389,6 +83652,33 @@ var NiumaDaemonRuntime = class {
       }
     }
   });
+  ipcThreadDiscovery = new RuntimeIpcThreadDiscovery({
+    eligible: (id5) => !this.lifecycle.stoppingValue && this.desktopSession.desktopIpcStateValue === "ready" && this.executionHost.appServerStateValue === "ready" && !this.archiveState.isConfirmed(id5) && !this.catalog.hasActiveTombstone(id5) && this.nativeAdmission.isVisible(id5) && !this.catalog.storeValue.getPublicThreadSummary(id5),
+    capture: () => {
+      const runtime = this.lifecycle.runtimeGenerationValue, ipc = this.desktopSession.ipcConnectionGenerationValue;
+      const client = this.executionHost.appServerValue, generation = this.appServerLoads.connectionGeneration;
+      return () => !this.lifecycle.stoppingValue && runtime === this.lifecycle.runtimeGenerationValue && ipc === this.desktopSession.ipcConnectionGenerationValue && client === this.executionHost.appServerValue && generation === this.appServerLoads.connectionGeneration;
+    },
+    read: (id5) => this.nativeAdmission.ensureSummary(id5, this.appServerLoads.connectionGeneration),
+    current: (token3) => this.nativeAdmission.isCurrent(token3),
+    enqueue: (run) => this.eventSequencer.enqueue(async () => {
+      run();
+    }),
+    commit: (thread4) => {
+      this.directoryAuthority.begin(false);
+      this.catalog.upsertAuthoritativeThreadSummary(thread4);
+      this.emitEvent(this.publication.threadUpdatedEvent(thread4.id, "app_server", nowSeconds()));
+      this.activityPublication.publishGlobalStatusIfChanged();
+    },
+    diagnostic: (threadId2, phase, elapsedMs) => this.diagnostics.writeDebug({
+      component: "daemon",
+      channel: "ipc",
+      event: "ipc_thread_discovery",
+      threadId: threadId2,
+      phase,
+      attributes: { durationMs: elapsedMs }
+    })
+  });
   async ensureNativeAdmission(id5) {
     return !this.lifecycle.stoppingValue && !this.archiveState.isConfirmed(id5) && await this.nativeAdmission.ensure(id5, this.appServerLoads.connectionGeneration) === "ordinary";
   }
@@ -84075,7 +84365,7 @@ var NiumaDaemonRuntime = class {
     isBlocked: isStartBlockedByLifecycle
   });
   // 所有 runtime 与 coordinator 共用同一审计实例，确保 thread-scope 事件可关联当前 trace。
-  threadLoadReports = new ThreadLoadReports();
+  threadLoadReports = new ThreadLoadReports(Date.now, () => this.followerOpenTraceAudit);
   followerOpenTraceAudit;
   // 异步选择只等待目录；端口在实际调用时读取，不能提前冻结Owner或缓存。
   settingsSelection = new RuntimeSettingsSelection({
@@ -84413,6 +84703,34 @@ var NiumaDaemonRuntime = class {
   });
 };
 
+// apps/desktop/src/daemon/thread-load-record.ts
+import { z as z17 } from "zod";
+var LoadRecordSchema = z17.object({
+  schema_version: z17.literal(3),
+  record_type: z17.enum(["load_start", "load_sample", "load_terminal", "load_close"]),
+  load_id: z17.string().uuid(),
+  thread_id: z17.string().min(1).max(256),
+  sequence: z17.number().int().nonnegative(),
+  occurred_at_ms: z17.number().int().nonnegative().max(864e13),
+  clock: z17.enum(["client", "daemon"]),
+  phase: z17.enum([...CLIENT_LOAD_PHASES, "open_received", "identity_ready", "lease_acquired", "shell_sent", "history_sent", "stream_closed", "failed", "cancelled", "superseded", "closed", "expired"]),
+  elapsed_ms: z17.number().int().min(0).max(9e5),
+  event_at_ms: z17.number().int().min(1).max(864e13).optional(),
+  source_transport: z17.enum(["local", "direct", "relay"]).optional(),
+  client_class: z17.enum(["web", "ios", "other"]).optional(),
+  title: z17.string().max(256).optional(),
+  lease_id: z17.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u).optional(),
+  trace_id: z17.string().regex(/^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u).optional(),
+  terminal_phase: z17.enum(["request_started", "snapshot_received", "history_ready", "open_received", "identity_ready", "lease_acquired", "shell_sent", "history_sent"]).optional(),
+  reason: z17.enum(["open_rejected", "history_failed", "left_view", "user_cancelled", "stream_replaced"]).optional()
+}).strict().superRefine((v, ctx) => {
+  const fail18 = () => ctx.addIssue({ code: "custom", message: "invalid_load_record" });
+  if (v.record_type === "load_start" && (v.phase !== "open_received" || v.clock !== "daemon" || !v.source_transport)) fail18();
+  if (v.record_type === "load_terminal" && !["failed", "cancelled", "superseded", "expired"].includes(v.phase)) fail18();
+  if (v.record_type === "load_close" && (v.phase !== "closed" || v.clock !== "daemon")) fail18();
+  if (v.record_type === "load_sample" && (v.clock === "client" ? !CLIENT_LOAD_PHASES.includes(v.phase) : !["open_received", "identity_ready", "lease_acquired", "shell_sent", "history_sent", "stream_closed"].includes(v.phase))) fail18();
+});
+
 // apps/desktop/src/daemon/follower-open-trace.ts
 import { randomUUID as randomUUID52 } from "node:crypto";
 import path51 from "node:path";
@@ -84421,6 +84739,7 @@ var MAX_FILE_BYTES2 = 5 * 1024 * 1024;
 var MAX_TOTAL_BYTES2 = 20 * 1024 * 1024;
 var MAX_LINE_BYTES2 = 64 * 1024;
 var MAX_DIRECTORY_ENTRIES3 = 256;
+var MAX_PROCESSED_LINES2 = 1e4;
 var SUBSCRIPTION_TRACE_SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,255}$/u;
 var FOLLOWER_OPEN_TRACE_TITLE_MAX_LENGTH = 256;
 var TRANSPORTS = /* @__PURE__ */ new Set(["local", "direct", "relay"]);
@@ -84582,6 +84901,9 @@ function isOptionalTraceTitle(value) {
 function hasOnlyKeys2(value, allowed) {
   return value !== null && typeof value === "object" && !Array.isArray(value) && Object.keys(value).every((key) => allowed.includes(key));
 }
+function isRecent(value, nowMs) {
+  return value <= nowMs && nowMs - value <= DAEMON_LOG_RETENTION_MS;
+}
 function dateFileName2(timestampMs) {
   return `${new Date(timestampMs).toISOString().slice(0, 10)}.ndjson`;
 }
@@ -84688,6 +85010,10 @@ function parseRecord2(line) {
   }
   if (value === null || typeof value !== "object" || Array.isArray(value)) return null;
   const record25 = value;
+  if (record25.schema_version === 3) {
+    const parsed = LoadRecordSchema.safeParse(record25);
+    return parsed.success ? parsed.data : null;
+  }
   if (record25.schema_version === 1) return parseV1Record(record25);
   if (record25.schema_version === 2) return parseV2Record(record25);
   return null;
@@ -84723,6 +85049,46 @@ function readPrivateTraceFile(file, remainingBytes, storage) {
     return { bytesRead: error2 instanceof PrivateLogFileError ? error2.bytesRead : 0, incomplete: true };
   }
 }
+function readRecords(runtimeDir, nowMs, storage) {
+  if (!Number.isFinite(nowMs)) return { records: [], incomplete: true };
+  const candidates = listPrivateTraceFiles(runtimeDir, storage);
+  const records = [];
+  let incomplete = candidates.incomplete;
+  let totalBytes = 0;
+  let processedLines = 0;
+  for (const filePath of candidates.files) {
+    if (totalBytes >= MAX_TOTAL_BYTES2) {
+      incomplete = true;
+      break;
+    }
+    const file = readPrivateTraceFile(filePath, MAX_TOTAL_BYTES2 - totalBytes, storage);
+    totalBytes += file.bytesRead;
+    if (file.incomplete) incomplete = true;
+    if (file.content === void 0) continue;
+    let end = file.content.endsWith("\n") ? file.content.length - 1 : file.content.length;
+    while (end > 0 && processedLines < MAX_PROCESSED_LINES2) {
+      const newline = file.content.lastIndexOf("\n", end - 1);
+      const start = newline + 1;
+      const length = end - start;
+      processedLines += 1;
+      if (length > 0 && length <= MAX_LINE_BYTES2) {
+        const line = file.content.slice(start, end);
+        if (Buffer.byteLength(line, "utf8") <= MAX_LINE_BYTES2) {
+          const record25 = parseRecord2(line);
+          if (record25 && timestampOf(record25) <= nowMs) records.push(record25);
+          else incomplete = true;
+        } else incomplete = true;
+      } else if (length > 0) incomplete = true;
+      end = Math.max(0, newline);
+    }
+    if (totalBytes >= MAX_TOTAL_BYTES2 || processedLines >= MAX_PROCESSED_LINES2) {
+      if (end > 0 || filePath !== candidates.files.at(-1)) incomplete = true;
+      break;
+    }
+  }
+  records.reverse();
+  return { records, incomplete: incomplete || hasIncompleteSubscriptionHistory(records, nowMs) };
+}
 function readPersistedSequenceFloor(runtimeDir, storage) {
   let maximum = 0;
   let totalBytes = 0;
@@ -84741,6 +85107,56 @@ function readPersistedSequenceFloor(runtimeDir, storage) {
   }
   return maximum;
 }
+function subscriptionIdentity(record25) {
+  return `${record25.trace_id}\0${record25.thread_id}\0${record25.lease_epoch}`;
+}
+function occursAfterStart(record25, trace) {
+  return record25.occurred_at_ms > trace.opened_at_ms || record25.occurred_at_ms === trace.opened_at_ms && record25.sequence > trace.sequence;
+}
+function occursBeforeClose(record25, close) {
+  return record25.occurred_at_ms < close.occurred_at_ms || record25.occurred_at_ms === close.occurred_at_ms && record25.sequence < close.sequence;
+}
+function hasIncompleteSubscriptionHistory(records, nowMs) {
+  const starts = /* @__PURE__ */ new Map();
+  const eventsByIdentity = /* @__PURE__ */ new Map();
+  const closesByIdentity = /* @__PURE__ */ new Map();
+  for (const record25 of records) {
+    if (record25.record_type === "subscription_start") {
+      const identity6 = subscriptionIdentity(record25);
+      if (starts.has(identity6)) return true;
+      starts.set(identity6, record25);
+      continue;
+    }
+    if (record25.record_type === "lease_event" || record25.record_type === "subscription_event") {
+      const identity6 = subscriptionIdentity(record25);
+      const events = eventsByIdentity.get(identity6) ?? [];
+      events.push(record25);
+      eventsByIdentity.set(identity6, events);
+      continue;
+    }
+    if (record25.record_type === "subscription_close") {
+      const identity6 = subscriptionIdentity(record25);
+      const closes = closesByIdentity.get(identity6) ?? [];
+      closes.push(record25);
+      closesByIdentity.set(identity6, closes);
+    }
+  }
+  for (const [identity6, events] of eventsByIdentity) {
+    const start = starts.get(identity6);
+    if (!start || events.some((event) => !occursAfterStart(event, start))) return true;
+  }
+  for (const start of starts.values()) {
+    const identity6 = subscriptionIdentity(start);
+    const closes = closesByIdentity.get(identity6) ?? [];
+    if (closes.some((close2) => !occursAfterStart(close2, start))) return true;
+    if (closes.length > 1) return true;
+    const close = closes[0];
+    if (close && (eventsByIdentity.get(identity6) ?? []).some((event) => !occursBeforeClose(event, close))) return true;
+    if (!close && !isRecent(start.opened_at_ms, nowMs)) return true;
+  }
+  if ([...closesByIdentity.keys()].some((identity6) => !starts.has(identity6))) return true;
+  return false;
+}
 var FollowerOpenTraceAuditWriter = class {
   constructor(runtimeDir, nowMs, files) {
     this.runtimeDir = runtimeDir;
@@ -84754,6 +85170,30 @@ var FollowerOpenTraceAuditWriter = class {
   nowMs;
   files;
   sequence;
+  loadEpoch = 0;
+  loadIds;
+  reserveLoadId(id5) {
+    if (!this.loadIds) {
+      try {
+        this.ensureTraceDirectory(path51.join(this.runtimeDir, TRACE_DIRECTORY_NAME));
+      } catch {
+        return false;
+      }
+      const read = readRecords(this.runtimeDir, this.nowMs(), this.files);
+      if (read.incomplete) return false;
+      this.loadIds = new Set(read.records.filter((r) => r.schema_version === 3).map((r) => r.load_id));
+    }
+    if (this.loadIds.size >= 1e4 || this.loadIds.has(id5)) return false;
+    this.loadIds.add(id5);
+    return true;
+  }
+  loadGeneration() {
+    return this.loadEpoch;
+  }
+  recordLoad(input) {
+    const parsed = LoadRecordSchema.safeParse({ ...input, schema_version: 3, sequence: this.nextSequence() });
+    if (parsed.success) this.write(parsed.data);
+  }
   traceDirectoryInitialized = false;
   /** 只缓存当前追加文件；日期切换或清空后重新发现已有分片。 */
   appendFilePath;
@@ -84887,6 +85327,7 @@ var FollowerOpenTraceAuditWriter = class {
         for (const entry of matching) this.files.remove(entry.file);
       }
       this.appendFilePath = void 0;
+      this.loadEpoch += 1;
       this.activeTraces.clear();
       this.activeSubscriptionTraces.clear();
       this.activeSubscriptionTraceHandles.clear();
@@ -85126,16 +85567,16 @@ import { dirname as dirname5, join as join3 } from "node:path";
 
 // apps/desktop/src/daemon/async-input-notification-store.ts
 import { createHash as createHash41 } from "node:crypto";
-import { z as z17 } from "zod";
+import { z as z18 } from "zod";
 var ASYNC_INPUT_NOTIFICATION_MAX_BYTES = 2 * 1024 * 1024;
-var identityText = z17.string().min(1).max(8e3);
-var entrySchema2 = z17.object({
-  key: z17.string().regex(/^[a-f0-9]{64}$/),
+var identityText = z18.string().min(1).max(8e3);
+var entrySchema2 = z18.object({
+  key: z18.string().regex(/^[a-f0-9]{64}$/),
   threadId: identityText,
   turnId: identityText,
-  stage: z17.enum(["admitted", "sent"])
+  stage: z18.enum(["admitted", "sent"])
 }).strict();
-var documentSchema2 = z17.object({ version: z17.literal(1), entries: z17.array(entrySchema2).max(4096) }).strict();
+var documentSchema2 = z18.object({ version: z18.literal(1), entries: z18.array(entrySchema2).max(4096) }).strict();
 var AsyncInputNotificationStore = class _AsyncInputNotificationStore {
   constructor(journal, document) {
     this.journal = journal;