@supercorks/krnl 0.1.4 → 0.1.5

package/dist/kernel-companion.mjs

@@ -15612,7 +15612,7 @@ function date4(params) {
 config(en_default());
 
 // src/hooks.ts
-import { readdir, mkdir as mkdir2, open as open2 } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
 import { join as join2 } from "node:path";
 import { homedir as homedir2 } from "node:os";
 import { randomUUID as randomUUID2 } from "node:crypto";
@@ -15626,7 +15626,8 @@ import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { createHash, randomUUID } from "node:crypto";
 var dataRoot = join(homedir(), "Library/Application Support/Kernel/Codex");
-var execute = promisify(execFile);
+var executeFile = promisify(execFile);
+var execute = (file2, args, options = {}) => executeFile(file2, args, { timeout: 1e4, maxBuffer: 4e6, ...options, encoding: "utf8" });
 function pairingDirectory(id) {
   return join(dataRoot, "machines", external_exports.uuid().parse(id));
 }
@@ -15793,6 +15794,16 @@ var hookEvents = [
   "PostToolUse",
   "SessionEnd"
 ];
+var observationSchema = external_exports.object({
+  threadId: external_exports.uuid(),
+  turnId: external_exports.string().max(200).nullable(),
+  event: external_exports.enum(hookEvents),
+  tool: external_exports.string().max(200).nullable(),
+  at: external_exports.number().finite().nonnegative(),
+  pid: external_exports.number().int().positive(),
+  identity: external_exports.string().max(500).optional(),
+  draft: external_exports.object({ launchId: external_exports.uuid(), cwd: external_exports.string().min(1).max(4096) }).optional()
+});
 function observation(raw, pid, at2 = performance.timeOrigin + performance.now()) {
   const input = external_exports.object({
     session_id: external_exports.uuid(),
@@ -15916,23 +15927,19 @@ async function captureHook(raw) {
   const machines = await readdir(join2(dataRoot, "machines")).catch(() => []);
   for (const machineId of machines) {
     if (!external_exports.uuid().safeParse(machineId).success) continue;
-    const directory = join2(dataRoot, "machines", machineId);
-    const index = await readJson(join2(directory, "threads.json"));
-    let captured = event;
-    if (!index?.[event.threadId]) {
-      const drafts = await readJson(join2(directory, "drafts.json"));
-      const match = drafts && await matchDraftSubmission(raw, drafts);
-      if (!match) continue;
-      captured = { ...event, draft: { launchId: match.launchId, cwd: match.cwd } };
-    }
-    const events = join2(directory, "events");
-    await mkdir2(events, { recursive: true, mode: 448 });
-    const file2 = await open2(join2(events, `${event.at}-${randomUUID2()}.json`), "wx", 384);
     try {
-      await file2.writeFile(JSON.stringify(captured));
-      await file2.sync();
-    } finally {
-      await file2.close();
+      const directory = join2(dataRoot, "machines", machineId);
+      const index = await readJson(join2(directory, "threads.json"));
+      let captured = event;
+      if (!index?.[event.threadId]) {
+        const drafts = await readJson(join2(directory, "drafts.json"));
+        const match = drafts && await matchDraftSubmission(raw, drafts);
+        if (!match) continue;
+        captured = { ...event, draft: { launchId: match.launchId, cwd: match.cwd } };
+      }
+      const events = join2(directory, "events");
+      await writeJson(join2(events, `${event.at}-${randomUUID2()}.json`), captured);
+    } catch {
     }
   }
 }
@@ -15947,21 +15954,48 @@ function kernelOrigin(raw) {
   return url2.origin;
 }
 var KernelConnectionError = class extends Error {
-  constructor(status2) {
+  constructor(status2, code, retryAfterMs) {
     super(
-      status2 === 401 ? "The machine pairing was revoked or is no longer authorized" : "Kernel could not acknowledge the companion request"
+      status2 === 401 || status2 === 403 ? "The connection is no longer authorized. Run krnl login, then krnl connect codex." : code === "codex_stale_connection" ? "This connection was replaced. Run krnl connect codex to repair setup." : `Kernel rejected a companion delivery (${code ?? status2}). Run krnl status for recovery details.`
     );
     this.status = status2;
+    this.code = code;
+    this.retryAfterMs = retryAfterMs;
   }
   status;
+  code;
+  retryAfterMs;
+  get fatal() {
+    return [401, 403].includes(this.status) || this.code === "codex_stale_connection";
+  }
+  get retryable() {
+    return this.code === "codex_disabled" || this.status === 408 || this.status === 429 || this.status >= 500;
+  }
 };
 async function postKernel(origin, operation, payload, credential) {
+  const controller = new AbortController();
+  let timer;
+  try {
+    return await Promise.race([
+      requestKernel(origin, operation, payload, credential, controller.signal),
+      new Promise((_2, reject) => {
+        timer = setTimeout(() => {
+          controller.abort();
+          reject(new Error("Kernel did not acknowledge the request within ten seconds"));
+        }, 1e4);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function requestKernel(origin, operation, payload, credential, signal) {
   const response = await fetch(
     `${kernelOrigin(origin)}/api/integrations/codex/companion/${operation}`,
     {
       method: "POST",
       redirect: "error",
-      signal: AbortSignal.timeout(1e4),
+      signal,
       headers: {
         "content-type": "application/json",
         ...credential ? {
@@ -15973,10 +16007,20 @@ async function postKernel(origin, operation, payload, credential) {
     }
   );
   if (!response.ok) {
-    await response.body?.cancel();
-    throw new KernelConnectionError(response.status);
+    const retry = response.headers.get("retry-after");
+    const retryAfterMs = retry ? /^\d+$/.test(retry) ? Number(retry) * 1e3 : Math.max(0, Date.parse(retry) - Date.now()) : void 0;
+    const body = await response.json().catch(() => void 0);
+    const rawCode = body?.error?.code;
+    const code = typeof rawCode === "string" && /^[a-zA-Z0-9_:-]{1,100}$/.test(rawCode) ? rawCode : void 0;
+    throw new KernelConnectionError(
+      response.status,
+      code,
+      Number.isFinite(retryAfterMs) ? retryAfterMs : void 0
+    );
   }
   const result = await response.json();
+  if (!result || result.data === void 0)
+    throw new Error("Kernel returned an invalid acknowledgment");
   return result.data;
 }
 function connection(pairing, token, connectionId) {
@@ -16088,11 +16132,11 @@ var AppServer = class extends EventEmitter {
     await new Promise((resolve3, reject) => {
       const finish = () => {
         clearTimeout(escalate);
-        clearTimeout(deadline);
+        clearTimeout(deadline2);
         resolve3();
       };
       const escalate = setTimeout(() => this.child.kill("SIGKILL"), 3e3);
-      const deadline = setTimeout(() => {
+      const deadline2 = setTimeout(() => {
         clearTimeout(escalate);
         this.child.off("exit", finish);
         reject(new Error("The owned Codex process did not release its task"));
@@ -16104,75 +16148,184 @@ var AppServer = class extends EventEmitter {
 };
 
 // src/projects.ts
-import { mkdir as mkdir3, realpath as realpath2, stat } from "node:fs/promises";
+import { mkdir as mkdir2, realpath as realpath2, stat } from "node:fs/promises";
 import { join as join3, isAbsolute } from "node:path";
+
+// src/recovery.ts
+var ReceiptQueue = class {
+  tails = /* @__PURE__ */ new Map();
+  run(id, action) {
+    const previous = this.tails.get(id) ?? Promise.resolve();
+    const next = previous.catch(() => void 0).then(action);
+    this.tails.set(id, next);
+    void next.finally(() => {
+      if (this.tails.get(id) === next) this.tails.delete(id);
+    }).catch(() => void 0);
+    return next;
+  }
+};
+function retryFailure(error51, prior, now = Date.now(), random = Math.random) {
+  const attempts = (prior?.attempts ?? 0) + 1;
+  const state = {
+    attempts,
+    pendingSince: Math.min(prior?.pendingSince ?? now, now),
+    nextAttemptAt: now
+  };
+  if (error51 instanceof KernelConnectionError && !error51.retryable) {
+    state.blocked = { code: error51.code ?? `http_${error51.status}`, message: error51.message };
+  } else {
+    const backoff = Math.min(3e4, 1e3 * 2 ** Math.min(attempts, 5));
+    state.nextAttemptAt = now + Math.max(
+      1e3 + random() * (backoff - 1e3),
+      error51 instanceof KernelConnectionError ? error51.retryAfterMs ?? 0 : 0
+    );
+  }
+  return state;
+}
+function retryReady(state, now = Date.now()) {
+  return !state?.blocked && (!state || state.nextAttemptAt <= now || now < state.pendingSince);
+}
+async function mapConcurrent(items, count, action) {
+  let cursor = 0;
+  const results = new Array(items.length);
+  const settled = await Promise.allSettled(
+    Array.from({ length: Math.min(count, items.length) }, async () => {
+      for (; ; ) {
+        const index = cursor++;
+        if (index >= items.length) return;
+        results[index] = await action(items[index]);
+      }
+    })
+  );
+  const failure = settled.find((result) => result.status === "rejected");
+  if (failure?.status === "rejected") throw failure.reason;
+  return results;
+}
+async function deadline(work, milliseconds) {
+  let timer;
+  try {
+    return await Promise.race([
+      work,
+      new Promise((_2, reject) => {
+        timer = setTimeout(() => reject(new Error("Local operation timed out")), milliseconds);
+      })
+    ]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var RuntimeLanes = class {
+  constructor(onError) {
+    this.onError = onError;
+  }
+  onError;
+  lanes = /* @__PURE__ */ new Map();
+  start(name, interval, action) {
+    const lane = this.lanes.get(name) ?? { at: -Infinity };
+    if (lane.work || performance.now() - lane.at < interval) return;
+    lane.at = performance.now();
+    lane.work = action().catch((error51) => this.onError(name, error51)).finally(() => {
+      delete lane.work;
+    });
+    this.lanes.set(name, lane);
+  }
+  async settle(milliseconds = 250) {
+    await deadline(this.drain(), milliseconds).catch(() => void 0);
+  }
+  async drain() {
+    for (; ; ) {
+      const work = [...this.lanes.values()].flatMap((lane) => lane.work ? [lane.work] : []);
+      if (!work.length) return;
+      await Promise.all(work);
+    }
+  }
+};
+
+// src/projects.ts
 async function discoverProjects(server) {
+  const signal = AbortSignal.timeout(25e3);
   const projects = [];
+  const visited = /* @__PURE__ */ new Set();
   let cursor;
   do {
+    signal.throwIfAborted();
     const page = await server.call(
       "project/list",
-      { limit: 100, ...cursor ? { cursor } : {} }
+      { limit: 100, ...cursor ? { cursor } : {} },
+      5e3
     );
     projects.push(...page.data);
     cursor = page.nextCursor ?? void 0;
+    if (cursor && visited.has(cursor)) throw new Error("Codex returned a repeated project page");
+    if (cursor) visited.add(cursor);
     if (projects.length > 500) throw new Error("The saved project catalog exceeds 500 projects");
   } while (cursor);
-  const discovered = await Promise.all(
-    projects.map(async (project) => {
-      const unavailable = (issue2) => ({
-        id: project.id,
-        name: project.name,
-        root: project.roots[0]?.path || "/",
-        isGit: false,
-        defaultBranch: null,
-        issue: issue2
-      });
-      if (project.roots.length !== 1)
-        return unavailable("Only saved projects with one local folder are supported.");
-      let root;
-      try {
-        root = await realpath2(project.roots[0].path);
-        if (!(await stat(root)).isDirectory())
-          return unavailable("The saved project folder is unavailable.");
-      } catch {
+  const discovered = await mapConcurrent(projects, 8, async (project) => {
+    signal.throwIfAborted();
+    const unavailable = (issue2) => ({
+      id: project.id,
+      name: project.name,
+      root: project.roots[0]?.path || "/",
+      isGit: false,
+      defaultBranch: null,
+      issue: issue2
+    });
+    if (project.roots.length !== 1)
+      return unavailable("Only saved projects with one local folder are supported.");
+    let root;
+    try {
+      root = await deadline(realpath2(project.roots[0].path), 2e3);
+      if (!(await deadline(stat(root), 2e3)).isDirectory())
         return unavailable("The saved project folder is unavailable.");
-      }
-      let isGit = false;
-      let defaultBranch = null;
-      try {
-        const top = (await execute("git", ["-C", root, "rev-parse", "--show-toplevel"])).stdout.trim();
-        isGit = await realpath2(top) === root;
-        if (isGit)
-          defaultBranch = (await execute("git", [
-            "-C",
-            root,
-            "symbolic-ref",
-            "--short",
-            "refs/remotes/origin/HEAD"
-          ])).stdout.trim() || null;
-      } catch {
-      }
-      return { id: project.id, name: project.name, root, isGit, defaultBranch };
-    })
-  );
+    } catch {
+      return unavailable("The saved project folder is unavailable.");
+    }
+    let isGit = false;
+    let defaultBranch = null;
+    try {
+      const top = (await execute("git", ["-C", root, "rev-parse", "--show-toplevel"], {
+        signal,
+        timeout: 5e3
+      })).stdout.trim();
+      isGit = await deadline(realpath2(top), 2e3) === root;
+      if (isGit)
+        defaultBranch = (await execute(
+          "git",
+          ["-C", root, "symbolic-ref", "--short", "refs/remotes/origin/HEAD"],
+          { signal, timeout: 5e3 }
+        )).stdout.trim() || null;
+    } catch (error51) {
+      signal.throwIfAborted();
+      if (error51.killed)
+        return unavailable(
+          "The saved project\u2019s Git metadata could not be verified. Discovery will retry."
+        );
+    }
+    return { id: project.id, name: project.name, root, isGit, defaultBranch };
+  });
+  signal.throwIfAborted();
   return discovered;
 }
+var DestinationAuthorizationError = class extends Error {
+};
 function authorizedDestination(pairing, launch, catalog2) {
   const authorized = pairing.projects.find((project) => project.id === launch.destination.id);
   const current = catalog2.find((project) => project.id === launch.destination.id);
   if (!current || Boolean(current.issue) || pairing.projectAccess !== "all-saved" && (!authorized || authorized.root !== current.root) || launch.destination.root !== current.root)
-    throw new Error("This saved project is not locally authorized at the submitted folder");
+    throw new DestinationAuthorizationError(
+      "This saved project is not locally authorized at the submitted folder"
+    );
   if (launch.checkout === "worktree" && (!current.isGit || !current.defaultBranch || current.defaultBranch !== launch.destination.defaultBranch))
-    throw new Error("The submitted default branch is no longer available");
-  if (!isAbsolute(current.root)) throw new Error("The saved project folder must be absolute");
+    throw new DestinationAuthorizationError("The submitted default branch is no longer available");
+  if (!isAbsolute(current.root))
+    throw new DestinationAuthorizationError("The saved project folder must be absolute");
   return current;
 }
 async function prepareCheckout(project, launch, directory) {
   if (launch.checkout === "folder") return project.root;
   if (!project.isGit || !project.defaultBranch) throw new Error("A Git default branch is required");
   const cwd = join3(directory, "worktrees", launch.id);
-  await mkdir3(join3(directory, "worktrees"), { recursive: true, mode: 448 });
+  await mkdir2(join3(directory, "worktrees"), { recursive: true, mode: 448 });
   await execute("git", [
     "-C",
     project.root,
@@ -16194,7 +16347,7 @@ async function prepareCheckout(project, launch, directory) {
 
 // src/runtime.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
-import { readdir as readdir2, unlink } from "node:fs/promises";
+import { readdir as readdir2, unlink, rename as rename2, mkdir as mkdir3 } from "node:fs/promises";
 import { join as join4 } from "node:path";
 import { homedir as homedir3 } from "node:os";
 import { setTimeout as delay } from "node:timers/promises";
@@ -22201,6 +22354,7 @@ var codexHealthSchema = external_exports.strictObject({
   supportsThreadLinking: external_exports.boolean().optional(),
   supportsTaskNamePrefix: external_exports.boolean().optional(),
   supportsDrafts: external_exports.boolean().optional(),
+  supportsStatusFreshness: external_exports.boolean().optional(),
   models: external_exports.array(codexModelSchema).max(100).optional(),
   appServerVersion: external_exports.string().max(100),
   desktopVersion: external_exports.string().max(100),
@@ -22240,6 +22394,7 @@ var deleteCodexMappingSchema = external_exports.strictObject({
 var launchCodexTaskSchema = external_exports.strictObject({
   protocolVersion,
   requestId: external_exports.uuid(),
+  submissionDeadline: external_exports.iso.datetime().optional(),
   taskId: external_exports.uuid(),
   taskVersion: external_exports.number().int().positive(),
   mode: codexModeSchema,
@@ -22300,7 +22455,13 @@ var codexDraftOpenedSchema = external_exports.strictObject({
   generation: sequence,
   launchId: external_exports.uuid()
 });
+var cancelCodexOperationSchema = external_exports.strictObject({
+  requestId: external_exports.uuid(),
+  taskId: external_exports.uuid(),
+  kind: external_exports.enum(["launch", "lookup"])
+});
 var codexStatusReportSchema = external_exports.strictObject({
+  observationAgeMs: external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
   launchId: external_exports.uuid(),
   sequence,
   state: external_exports.enum(["running", "done", "unreachable"]),
@@ -22615,12 +22776,13 @@ async function commonGitDirectory(folder) {
       timeout: 1500,
       maxBuffer: 8192
     });
-    return await realpath3(resolve(folder, stdout.trim()));
+    return await deadline(realpath3(resolve(folder, stdout.trim())), 2e3);
   } catch {
     return null;
   }
 }
-async function resolveThreadProject(thread, pairing, catalog2) {
+async function resolveThreadProject(thread, pairing, catalog2, signal = AbortSignal.timeout(2e4)) {
+  signal.throwIfAborted();
   const authorized = catalog2.filter(
     (project) => !project.issue && (pairing.projectAccess === "all-saved" || pairing.projects.some(
       (allowed) => allowed.id === project.id && allowed.root === project.root
@@ -22628,19 +22790,21 @@ async function resolveThreadProject(thread, pairing, catalog2) {
   );
   let cwd;
   try {
-    cwd = await realpath3(thread.cwd);
-    if (!(await stat2(cwd)).isDirectory()) return null;
+    cwd = await deadline(realpath3(thread.cwd), 2e3);
+    if (!(await deadline(stat2(cwd), 2e3)).isDirectory()) return null;
   } catch {
     return null;
   }
   const candidates = thread.projectId ? authorized.filter((project) => project.id === thread.projectId) : [...authorized].sort((a2, b2) => b2.root.length - a2.root.length);
   for (const project of candidates) {
-    if (await realpath3(project.root).catch(() => null) !== project.root) continue;
+    signal.throwIfAborted();
+    if (await deadline(realpath3(project.root), 2e3).catch(() => null) !== project.root) continue;
     if (inside(project.root, cwd)) return { project, cwd };
   }
   const common = candidates.some((project) => project.isGit) ? await commonGitDirectory(cwd) : null;
   if (common)
     for (const project of candidates) {
+      signal.throwIfAborted();
       if (project.isGit && await commonGitDirectory(project.root) === common)
         return { project, cwd };
     }
@@ -22701,6 +22865,7 @@ var CodexThreadLookupService = class {
     return this.loading;
   }
   async lookup(server, raw, pairing, catalog2) {
+    const signal = AbortSignal.timeout(25e3);
     const work = codexThreadLookupWorkSchema.parse(raw);
     let candidates;
     if (work.threadId) {
@@ -22720,7 +22885,9 @@ var CodexThreadLookupService = class {
     for (const thread of candidates) {
       if (this.now() - started > 2e4)
         throw new Error("Refine the title or paste a Codex task link.");
-      const destination = await resolveThreadProject(thread, pairing, catalog2);
+      signal.throwIfAborted();
+      const destination = await resolveThreadProject(thread, pairing, catalog2, signal);
+      signal.throwIfAborted();
       if (!destination) continue;
       if (results.length === CODEX_THREAD_RESULT_LIMIT) return { results, hasMore: true };
       results.push({
@@ -22785,33 +22952,53 @@ function initialReceipt(launch) {
 function canBegin(receipt, now) {
   return receipt.phase === "prepared" && "expiresAt" in receipt.launch && now < Date.parse(receipt.launch.expiresAt);
 }
-async function findCreation(server, receipt) {
-  let cursor = null;
-  let found;
-  do {
-    const page = await server.call("thread/list", {
-      projectId: receipt.launch.destination.id,
-      ...receipt.cwd ? { cwd: receipt.cwd } : {},
-      limit: 100,
-      modelProviders: [],
-      ...cursor ? { cursor } : {}
-    });
-    for (const candidate of page.data) {
-      if (candidate.createdAt * 1e3 < receipt.preparedAt - 5e3) continue;
-      const { thread } = await server.call("thread/read", { threadId: candidate.id, includeTurns: false });
-      if (thread.threadSource !== sourceMarker(receipt.launch.id)) continue;
-      if (found) throw new Error("Multiple creation receipts require local reconciliation");
-      found = thread;
-    }
-    cursor = page.nextCursor ?? null;
-  } while (cursor);
-  return found;
+var CreationConflictError = class extends Error {
+};
+async function findCreation(server, receipt, search = {}, budget = Infinity) {
+  while (!search.done && budget-- > 0) {
+    if (!search.candidates?.length) {
+      if (search.cursor === null) {
+        search.done = true;
+        break;
+      }
+      const page = await server.call(
+        "thread/list",
+        {
+          projectId: receipt.launch.destination.id,
+          ...receipt.cwd ? { cwd: receipt.cwd } : {},
+          limit: 100,
+          modelProviders: [],
+          ...search.cursor ? { cursor: search.cursor } : {}
+        },
+        2e3
+      );
+      search.candidates = page.data.filter(
+        (candidate2) => candidate2.createdAt * 1e3 >= receipt.preparedAt - 5e3
+      );
+      search.cursor = page.nextCursor ?? null;
+      continue;
+    }
+    const candidate = search.candidates[0];
+    const { thread } = await server.call("thread/read", { threadId: candidate.id, includeTurns: false }, 2e3);
+    if (thread.threadSource === sourceMarker(receipt.launch.id)) {
+      if (search.found)
+        throw new CreationConflictError("Multiple creation receipts require local reconciliation");
+      search.found = thread;
+    }
+    search.candidates.shift();
+  }
+  if (!search.candidates?.length && search.cursor === null) search.done = true;
+  return search.done ? search.found : void 0;
 }
 async function runCompanion(machineId, entrypoint2, signal) {
   const directory = pairingDirectory(machineId);
   const unlock = await processLock(directory);
   const owners = /* @__PURE__ */ new Map();
   let observer;
+  let catalogServer;
+  let lanes;
+  let stopping = false;
+  let persistDiagnostics;
   let lookupServer;
   let lookupWork;
   try {
@@ -22824,17 +23011,95 @@ async function runCompanion(machineId, entrypoint2, signal) {
     await writeJson(join4(directory, "generation.json"), pairing.generation);
     const post = connection(pairing, await readCredential(machineId), randomUUID3());
     const receipts = /* @__PURE__ */ new Map();
-    const acknowledged = /* @__PURE__ */ new Set();
-    const reported = /* @__PURE__ */ new Map();
+    const entries = async (path) => {
+      try {
+        return await readdir2(path);
+      } catch (error51) {
+        if (error51.code === "ENOENT") return [];
+        throw error51;
+      }
+    };
+    const writers = new ReceiptQueue();
+    const blocked = /* @__PURE__ */ new Set();
+    const searches = /* @__PURE__ */ new Map();
+    const quarantine = async (path, id) => {
+      await mkdir3(join4(directory, "quarantine"), { recursive: true, mode: 448 });
+      if (id) {
+        blocked.add(id);
+        await writeJson(join4(directory, "blocked", `${id}.json`), {
+          code: "invalid_receipt",
+          message: "A damaged creation receipt needs local recovery. This launch will not be repeated."
+        });
+      }
+      await rename2(path, join4(directory, "quarantine", `${randomUUID3()}.json`));
+    };
+    for (const file2 of await entries(join4(directory, "blocked")))
+      if (file2.endsWith(".json") && external_exports.uuid().safeParse(file2.slice(0, -5)).success)
+        blocked.add(file2.slice(0, -5));
     const inspected = /* @__PURE__ */ new Map();
+    const observations = /* @__PURE__ */ new Map();
+    const observe = (receipt, ageMs = 0) => {
+      receipt.observedAt = Date.now() - ageMs;
+      observations.set(receipt.launch.id, {
+        wall: receipt.observedAt,
+        monotonic: performance.now() - ageMs
+      });
+    };
     const receiptPath = (id) => join4(directory, "receipts", `${id}.json`);
     const save = (receipt) => writeJson(receiptPath(receipt.launch.id), receipt);
-    for (const file2 of await readdir2(join4(directory, "receipts")).catch(() => [])) {
+    for (const file2 of await entries(join4(directory, "receipts"))) {
       if (!file2.endsWith(".json")) continue;
-      const receipt = await readJson(join4(directory, "receipts", file2));
-      if (receipt) receipts.set(receipt.launch.id, receipt);
+      const id = file2.slice(0, -5);
+      let receipt;
+      try {
+        const stored = await readJson(join4(directory, "receipts", file2));
+        if (!stored) throw new Error("Missing receipt");
+        receipt = stored;
+        if (!receipt || !external_exports.uuid().safeParse(id).success || receipt.launch?.id !== id || !Number.isFinite(receipt.preparedAt) || ![
+          "prepared",
+          "creating",
+          "created",
+          "starting",
+          "opening-draft",
+          "drafted",
+          "released",
+          "failed"
+        ].includes(receipt.phase))
+          throw new Error("Invalid receipt");
+        codexStatusReportSchema.parse(receipt.status);
+        if ("task" in receipt.launch) codexLaunchSchema.parse(receipt.launch);
+        else codexWatchSchema.parse(receipt.launch);
+      } catch {
+        await quarantine(
+          join4(directory, "receipts", file2),
+          external_exports.uuid().safeParse(id).success ? id : void 0
+        );
+        continue;
+      }
+      delete receipt.observedAt;
+      if (receipt.phase === "opening-draft") {
+        receipt.phase = "drafted";
+        receipt.draftOpenUncertain = true;
+      }
+      if (["prepared", "created", "starting"].includes(receipt.phase)) {
+        if (receipt.threadId) receipt.phase = "released";
+        else {
+          receipt.phase = "failed";
+          receipt.failure = "The companion stopped before creating the task. Start again when connected.";
+        }
+      }
+      if (receipt.phase === "released" && receipt.status.state === "running" && !receipt.status.waiting) {
+        receipt.status = {
+          ...receipt.status,
+          sequence: receipt.status.sequence + 1,
+          state: "unreachable",
+          message: "Checking the saved task after reconnection."
+        };
+      }
+      receipts.set(id, receipt);
+      await save(receipt);
     }
-    const indexThreads = async () => {
+    const indexThreads = () => writers.run("index", async () => {
       await writeJson(
         join4(directory, "threads.json"),
         Object.fromEntries(
@@ -22849,10 +23114,13 @@ async function runCompanion(machineId, entrypoint2, signal) {
           )
         )
       );
-    };
+    });
+    await indexThreads();
     const queue = [];
     const lookupService = new CodexThreadLookupService();
     let lookupBusy = false;
+    const lookupRetries = /* @__PURE__ */ new Map();
+    const lookupExpiries = /* @__PURE__ */ new Map();
     const lookupResults = [];
     const watched = /* @__PURE__ */ new Map();
     const watchAttempts = /* @__PURE__ */ new Map();
@@ -22872,10 +23140,18 @@ async function runCompanion(machineId, entrypoint2, signal) {
       return lookupServer;
     };
     const connectObserver = async () => {
-      observer?.close();
-      observer = new AppServer(directory);
-      await observer.initialize();
-      return observer;
+      const next = new AppServer(directory);
+      try {
+        await next.initialize();
+        observer = next;
+        next.once("closed", () => {
+          if (observer === next) observer = void 0;
+        });
+        return next;
+      } catch (error51) {
+        next.close();
+        throw error51;
+      }
     };
     let catalog2 = [];
     let health = {
@@ -22891,8 +23167,14 @@ async function runCompanion(machineId, entrypoint2, signal) {
       issue: "Checking Codex compatibility."
     };
     let refreshed = 0;
-    let clockOffset = 0;
-    let reconciled = false;
+    let supportsFreshness = false;
+    let heartbeatHealth = "";
+    const laneRetries = /* @__PURE__ */ new Map();
+    let fatalError = null;
+    const laneErrors = /* @__PURE__ */ new Map();
+    let journalHealthy = true;
+    let clockAnchor;
+    const kernelNow = () => clockAnchor ? clockAnchor.server + Math.max(0, performance.now() - clockAnchor.monotonic) : Date.now();
     const release = async (receipt, waiting, message) => {
       const owner = owners.get(receipt.launch.id);
       receipt.status = {
@@ -22904,6 +23186,7 @@ async function runCompanion(machineId, entrypoint2, signal) {
         message
       };
       receipt.handoffWaiting = waiting;
+      observe(receipt);
       await save(receipt);
       if (waiting && owner && receipt.turnId)
         await owner.call("turn/interrupt", { threadId: receipt.threadId, turnId: receipt.turnId }).catch(() => void 0);
@@ -22914,12 +23197,12 @@ async function runCompanion(machineId, entrypoint2, signal) {
       await save(receipt);
     };
     const begin = async (launch) => {
-      if (receipts.has(launch.id)) return;
+      if (receipts.has(launch.id) || blocked.has(launch.id) || stopping || signal.aborted) return;
       const receipt = initialReceipt(launch);
       receipts.set(launch.id, receipt);
       await save(receipt);
       try {
-        if (launch.machineId !== machineId || launch.protocolVersion !== 1 || !canBegin(receipt, Date.now() + clockOffset))
+        if (launch.machineId !== machineId || launch.protocolVersion !== 1 || !canBegin(receipt, kernelNow()))
           throw new Error("The launch expired before local creation");
         const authorized = await readJson(join4(directory, "pairing.json"));
         if (!authorized) throw new Error("The local pairing is unavailable");
@@ -22942,6 +23225,8 @@ async function runCompanion(machineId, entrypoint2, signal) {
           receipt.phase = "opening-draft";
           await save(receipt);
           await indexThreads();
+          if (stopping || signal.aborted || kernelNow() >= Date.parse(launch.expiresAt))
+            throw new Error("The launch expired before desktop dispatch");
           await execute("/usr/bin/open", [url2]);
           receipt.phase = "drafted";
           await save(receipt);
@@ -22949,7 +23234,7 @@ async function runCompanion(machineId, entrypoint2, signal) {
         }
         receipt.cwd = await prepareCheckout(project, launch, directory);
         await save(receipt);
-        if (!canBegin(receipt, Date.now() + clockOffset))
+        if (!canBegin(receipt, kernelNow()))
           throw new Error("The launch expired during checkout preparation");
         const latestPairing = await readJson(join4(directory, "pairing.json"));
         if (!latestPairing) throw new Error("The local connection is unavailable");
@@ -22969,12 +23254,14 @@ async function runCompanion(machineId, entrypoint2, signal) {
         );
         await owner.initialize();
         const selection = resolveModelSelection(launch, await discoverModels(owner));
-        if (!canBegin(receipt, Date.now() + clockOffset))
+        if (!canBegin(receipt, kernelNow()))
           throw new Error("The launch expired while checking model availability");
         receipt.model = selection.model;
         receipt.effort = selection.reasoningEffort;
         receipt.phase = "creating";
         await save(receipt);
+        if (stopping || signal.aborted || kernelNow() >= Date.parse(launch.expiresAt))
+          throw new Error("The connection stopped or the launch expired before creation");
         const created = await owner.call("thread/start", {
           cwd: receipt.cwd,
           projectId: project.id,
@@ -22993,6 +23280,8 @@ async function runCompanion(machineId, entrypoint2, signal) {
         });
         receipt.phase = "starting";
         await save(receipt);
+        if (stopping || signal.aborted || kernelNow() >= Date.parse(launch.expiresAt))
+          throw new Error("The connection stopped or the launch expired before dispatch");
         const response = await owner.call("turn/start", {
           threadId: receipt.threadId,
           input: [{ type: "text", text: codexLaunchPrompt(launch) }],
@@ -23002,6 +23291,7 @@ async function runCompanion(machineId, entrypoint2, signal) {
             selection.reasoningEffort
           )
         });
+        observe(receipt);
         receipt.turnId = response.turn.id;
         receipt.status.turnId = response.turn.id;
         await save(receipt);
@@ -23048,153 +23338,181 @@ async function runCompanion(machineId, entrypoint2, signal) {
         await save(receipt);
       }
     };
-    while (!signal.aborted) {
-      const tickStarted = Date.now();
-      let networkError;
+    lanes = new RuntimeLanes((name, error51) => {
+      if (name === "events") journalHealthy = false;
+      const message = error51 instanceof KernelConnectionError ? error51.message : `${name} is temporarily unavailable; recovery will retry.`;
+      laneErrors.set(name, message);
+      laneRetries.set(name, retryFailure(error51, laneRetries.get(name)));
+      if (error51 instanceof KernelConnectionError && error51.fatal) {
+        stopping = true;
+        fatalError = message;
+        process.stdout.write(`${error51.message} The companion has stopped.
+`);
+      }
+    });
+    const schedule = (name, interval, work) => {
+      if (!stopping && retryReady(laneRetries.get(name)))
+        lanes.start(name, interval, async () => {
+          await work();
+          if (name === "events") journalHealthy = true;
+          laneRetries.delete(name);
+          laneErrors.delete(name);
+        });
+    };
+    const refreshCatalog = async () => {
       try {
-        if (Date.now() - refreshed >= 1e4) {
+        if (!catalogServer) {
+          catalogServer = new AppServer(directory);
+          await catalogServer.initialize();
+        }
+        if (!observer) await connectObserver();
+        const local = await readJson(join4(directory, "pairing.json"));
+        if (!local) throw new Error("The local connection is unavailable");
+        const discovered = await discoverProjects(catalogServer);
+        const authorized = discovered.filter(
+          (project) => local.projectAccess === "all-saved" || local.projects.some((p2) => p2.id === project.id && p2.root === project.root)
+        );
+        const ready = await hooksReady(catalogServer, [homedir3()], hookCommand(entrypoint2));
+        const projects = await mapConcurrent(authorized, 4, async (project) => {
+          if (project.issue) return project;
           try {
-            if (!observer) await connectObserver();
-            const local = await readJson(join4(directory, "pairing.json"));
-            if (!local) throw new Error("The local connection is unavailable");
-            const discovered = await discoverProjects(observer);
-            catalog2 = discovered.filter(
-              (project) => local.projectAccess === "all-saved" || local.projects.some(
-                (authorized) => authorized.id === project.id && authorized.root === project.root
-              )
-            );
-            const ready = await hooksReady(observer, [homedir3()], hookCommand(entrypoint2));
-            catalog2 = await Promise.all(
-              catalog2.map(async (project) => {
-                if (project.issue) return project;
-                try {
-                  return await hooksReady(observer, [project.root], hookCommand(entrypoint2)) ? project : {
-                    ...project,
-                    issue: "Kernel hooks are disabled or need review for this project. Open /hooks in Codex CLI from its folder."
-                  };
-                } catch {
-                  return {
-                    ...project,
-                    issue: "This project\u2019s Codex configuration could not be read."
-                  };
-                }
-              })
-            );
-            const { stdout } = await execute(codexExecutable(), ["--version"]);
-            const desktop = await execute("/usr/libexec/PlistBuddy", [
-              "-c",
-              "Print:CFBundleShortVersionString",
-              "/Applications/ChatGPT.app/Contents/Info.plist"
-            ]).then((result) => result.stdout.trim()).catch(() => "");
-            const models = await discoverModels(observer);
-            health = {
-              reachable: true,
-              hooksReady: ready,
-              supportsModelSelection: true,
-              supportsThreadLinking: true,
-              supportsTaskNamePrefix: true,
-              supportsDrafts: true,
-              models,
-              appServerVersion: stdout.trim(),
-              desktopVersion: desktop,
-              issue: ready ? null : "Review the eight Kernel hooks using /hooks in Codex CLI. The companion detects completed review automatically."
-            };
-          } catch (error51) {
-            observer?.close();
-            observer = void 0;
-            health = {
-              ...health,
-              reachable: false,
-              hooksReady: false,
-              models: [],
-              issue: error51 instanceof CodexModelSelectionError ? error51.message : "Codex could not be reached through its supported app-server interface."
+            return await hooksReady(catalogServer, [project.root], hookCommand(entrypoint2)) ? project : {
+              ...project,
+              issue: "Kernel hooks are disabled or need review for this project. Open /hooks in Codex CLI from its folder."
             };
+          } catch {
+            return { ...project, issue: "This project\u2019s Codex configuration could not be read." };
           }
+        });
+        const { stdout } = await execute(codexExecutable(), ["--version"]);
+        const desktop = await execute("/usr/libexec/PlistBuddy", [
+          "-c",
+          "Print:CFBundleShortVersionString",
+          "/Applications/ChatGPT.app/Contents/Info.plist"
+        ]).then((result) => result.stdout.trim()).catch(() => "");
+        const models = await discoverModels(catalogServer);
+        catalog2 = projects;
+        health = {
+          ...health,
+          reachable: true,
+          hooksReady: ready,
+          models,
+          appServerVersion: stdout.trim(),
+          desktopVersion: desktop,
+          issue: ready ? null : "Review the eight Kernel hooks using /hooks in Codex CLI. The companion detects completed review automatically."
+        };
+      } catch (error51) {
+        catalogServer?.close();
+        catalogServer = void 0;
+        health = {
+          ...health,
+          reachable: false,
+          hooksReady: false,
+          issue: error51 instanceof CodexModelSelectionError ? error51.message : "Codex could not be reached through its supported app-server interface."
+        };
+        throw error51;
+      }
+    };
+    const heartbeat = async () => {
+      const sentAt = performance.now();
+      const advertised = {
+        ...health,
+        ...supportsFreshness ? { supportsStatusFreshness: true } : {}
+      };
+      const response = await post("heartbeat", { health: advertised, projects: catalog2 });
+      const serverTime = Date.parse(response.serverTime);
+      if (!Number.isFinite(serverTime)) throw new Error("Kernel returned an invalid clock");
+      clockAnchor = {
+        server: serverTime + Math.max(0, performance.now() - sentAt),
+        monotonic: performance.now()
+      };
+      supportsFreshness = response.capabilities?.statusFreshness === true;
+      heartbeatHealth = JSON.stringify(health);
+      refreshed = performance.now();
+      schedule("launches", 2e3, launches);
+      schedule("lookups", 2e3, lookups);
+      await writeJson(join4(directory, "health.json"), {
+        at: Date.now(),
+        health: advertised,
+        projects: catalog2.length
+      });
+    };
+    let reconciliationCursor = 0;
+    const reconcile = async () => {
+      if (!observer) return;
+      const candidates = [...receipts.values()].filter(
+        (receipt) => receipt.phase === "creating" && !receipt.threadId && !owners.has(receipt.launch.id) && retryReady(receipt.reconciliation)
+      );
+      const batch = Array.from(
+        { length: Math.min(candidates.length, 4) },
+        () => candidates[reconciliationCursor++ % candidates.length]
+      );
+      await mapConcurrent(
+        batch,
+        2,
+        (receipt) => writers.run(receipt.launch.id, async () => {
           try {
-            const sentAt = Date.now();
-            const heartbeat = await post("heartbeat", {
-              health,
-              projects: catalog2
-            });
-            clockOffset = Date.parse(heartbeat.serverTime) - sentAt;
-            if (!Number.isFinite(clockOffset)) throw new Error("Kernel returned an invalid clock");
-            refreshed = Date.now();
-            await writeJson(join4(directory, "health.json"), {
-              at: refreshed,
-              health,
-              projects: catalog2.length
-            });
-          } catch (error51) {
-            networkError = error51;
-          }
-        }
-        if (observer) {
-          let recovered = false;
-          for (const receipt of receipts.values()) {
-            if (!reconciled && receipt.phase === "opening-draft") {
-              receipt.phase = "drafted";
-              receipt.draftOpenUncertain = true;
-            }
-            if (reconciled && (receipt.phase !== "creating" || owners.has(receipt.launch.id)))
-              continue;
-            if (receipt.phase === "creating" && !receipt.threadId && !owners.has(receipt.launch.id)) {
-              const found = await findCreation(observer, receipt);
-              if (found) {
-                receipt.threadId = found.id;
-                receipt.cwd = found.cwd;
-                receipt.phase = "released";
-                receipt.status = {
-                  ...receipt.status,
-                  sequence: receipt.status.sequence + 1,
-                  state: "unreachable",
-                  message: "Recovered the created task. Open it in Codex to check its first turn."
-                };
-                acknowledged.delete(receipt.launch.id);
-                recovered = true;
-              } else {
-                receipt.failure = "Codex creation could not be confirmed. This launch will not be repeated.";
-                receipt.ambiguous = true;
-              }
-            }
-            if (!reconciled && ["prepared", "created", "starting"].includes(receipt.phase)) {
-              if (receipt.threadId) receipt.phase = "released";
-              else {
-                receipt.phase = "failed";
-                receipt.failure = "The companion stopped before creating the task. Start again when connected.";
-              }
-            }
-            if (!reconciled && receipt.phase === "released" && receipt.status.state === "running" && !receipt.status.waiting)
+            const search = searches.get(receipt.launch.id) ?? {};
+            searches.set(receipt.launch.id, search);
+            const found = await findCreation(observer, receipt, search, 5);
+            if (found) {
+              receipt.threadId = found.id;
+              receipt.cwd = found.cwd;
+              receipt.phase = "released";
+              delete receipt.delivery;
               receipt.status = {
                 ...receipt.status,
                 sequence: receipt.status.sequence + 1,
                 state: "unreachable",
-                message: "Checking the saved task after reconnection."
+                message: "Recovered the created task. Open it in Codex to check its first turn."
+              };
+              await indexThreads();
+            } else if (search.done) {
+              receipt.failure = "Codex creation could not be confirmed. This launch will not be repeated.";
+              receipt.ambiguous = true;
+              searches.delete(receipt.launch.id);
+              receipt.reconciliation = retryFailure(
+                new Error("Creation is still uncertain"),
+                receipt.reconciliation
+              );
+            }
+            if (found) delete receipt.reconciliation;
+          } catch (error51) {
+            receipt.reconciliation = retryFailure(error51, receipt.reconciliation);
+            if (error51 instanceof CreationConflictError)
+              receipt.reconciliation.blocked = {
+                code: "ambiguous_creation",
+                message: "Multiple creation records need local review. This launch will not be repeated."
               };
-            await save(receipt);
           }
-          if (!reconciled || recovered) await indexThreads();
-          reconciled = true;
-        }
-        for (const receipt of watchResults.splice(0)) {
-          if (receipts.has(receipt.launch.id)) continue;
+          await save(receipt);
+        })
+      );
+    };
+    let eventCursor = 0;
+    const invalidEvents = /* @__PURE__ */ new Map();
+    const localEvents = async () => {
+      for (const receipt of watchResults.splice(0)) {
+        if (receipts.has(receipt.launch.id) || blocked.has(receipt.launch.id)) continue;
+        await writers.run(receipt.launch.id, async () => {
           receipts.set(receipt.launch.id, receipt);
           await save(receipt);
-          await indexThreads();
-        }
-        if (!networkError) {
-          while (lookupResults.length) {
-            await post("thread-lookup-result", lookupResults[0]);
-            lookupResults.shift();
-          }
-        }
-        for (const { launchId, event } of queue.splice(0)) {
+        });
+        await indexThreads();
+      }
+      const events = queue.splice(0);
+      await mapConcurrent(
+        events,
+        4,
+        ({ launchId, event }) => writers.run(launchId, async () => {
           const receipt = receipts.get(launchId);
-          if (!receipt || receipt.phase === "released" || receipt.phase === "failed") continue;
+          if (!receipt || receipt.phase === "released" || receipt.phase === "failed") return;
           if (event.method === "turn/started") {
             const turn = event.params?.turn;
             if (turn) {
               receipt.turnId = turn.id;
               receipt.status.turnId = turn.id;
+              observe(receipt);
               await save(receipt);
             }
           } else if (event.id !== void 0) {
@@ -23210,7 +23528,7 @@ async function runCompanion(machineId, entrypoint2, signal) {
               false,
               turn?.status === "failed" ? "Codex ended this turn with an error. Open the task for details." : null
             );
-          } else if (event.method === "kernel/closed") {
+          } else if (event.method === "kernel/closed" && receipt.threadId) {
             receipt.phase = "released";
             receipt.status = {
               ...receipt.status,
@@ -23220,176 +23538,342 @@ async function runCompanion(machineId, entrypoint2, signal) {
             };
             await save(receipt);
           }
-        }
-        for (const file2 of (await readdir2(join4(directory, "events")).catch(() => [])).sort()) {
-          if (!file2.endsWith(".json")) continue;
-          const path = join4(directory, "events", file2);
-          const event = await readJson(path);
-          let receipt = event && [...receipts.values()].find((r2) => r2.threadId === event.threadId);
-          if (!receipt && event?.draft && observer) {
-            const pending = receipts.get(event.draft.launchId);
-            if (pending && "mode" in pending.launch && pending.launch.mode === "draft" && !pending.threadId && ["opening-draft", "drafted"].includes(pending.phase) && event.draft.cwd === pending.cwd) {
-              try {
-                const authorized = await readJson(join4(directory, "pairing.json"));
-                if (!authorized) throw new Error("Connection unavailable");
-                authorizedDestination(authorized, pending.launch, await discoverProjects(observer));
-                pending.threadId = event.threadId;
-                pending.phase = "released";
-                acknowledged.delete(pending.launch.id);
-                receipt = pending;
-                await save(pending);
-                await indexThreads();
-              } catch {
-                pending.phase = "failed";
-                pending.failure = "The draft's saved project changed. Link the task from Codex using its task link.";
-                await save(pending);
-                await indexThreads();
-              }
-            }
+        })
+      );
+      const files = (await entries(join4(directory, "events"))).filter((file2) => file2.endsWith(".json")).sort();
+      const eventBatch = Array.from(
+        { length: Math.min(files.length, 100) },
+        () => files[eventCursor++ % files.length]
+      );
+      await mapConcurrent(eventBatch, 4, async (file2) => {
+        const path = join4(directory, "events", file2);
+        let event;
+        try {
+          event = observationSchema.parse(await readJson(path));
+        } catch {
+          const first = invalidEvents.get(file2);
+          if (first === void 0) invalidEvents.set(file2, performance.now());
+          else if (performance.now() - first >= 2e3) {
+            await quarantine(path);
+            invalidEvents.delete(file2);
           }
-          if (receipt && event && applyObservation(receipt, event)) await save(receipt);
-          await unlink(path);
+          return;
         }
-        let inspectionBudget = 4;
-        let deliveryBudget = 4;
-        for (const receipt of receipts.values()) {
-          if (receipt.phase === "released" && receipt.status.state !== "done" && !receipt.handoffWaiting && inspectionBudget > 0 && receipt.threadId && observer && Date.now() - (inspected.get(receipt.launch.id) ?? 0) > 5e3) {
-            inspectionBudget -= 1;
-            inspected.set(receipt.launch.id, Date.now());
+        invalidEvents.delete(file2);
+        const target = [...receipts.values()].find((r2) => r2.threadId === event.threadId) ?? (event.draft && receipts.get(event.draft.launchId));
+        if (!target) return;
+        await writers.run(target.launch.id, async () => {
+          if (!target.threadId && event.draft && "mode" in target.launch && target.launch.mode === "draft" && ["opening-draft", "drafted"].includes(target.phase) && event.draft.cwd === target.cwd) {
+            if (!observer) return;
             try {
-              const latest = await observer.call(
-                "thread/turns/list",
-                {
-                  threadId: receipt.threadId,
-                  limit: 1,
-                  itemsView: "notLoaded"
-                },
-                2e3
-              );
-              const turn = latest.data[0];
-              const matchesActive = receipt.status.state !== "running" || turn?.id === receipt.status.turnId;
-              if (turn && ["completed", "failed"].includes(turn.status) && matchesActive && !receipt.status.waiting) {
-                receipt.status = {
-                  ...receipt.status,
-                  sequence: receipt.status.sequence + 1,
-                  state: "done",
-                  waiting: false,
-                  turnId: turn.id,
-                  message: turn.status === "failed" ? "Codex ended this turn with an error. Open the task for details." : null
-                };
-                await save(receipt);
-              } else if (receipt.status.state === "running" && !receipt.handoffWaiting && !await observedProcessAlive(receipt.pid, receipt.nativeIdentity) && receipt.hookAt) {
-                receipt.status = {
-                  ...receipt.status,
-                  sequence: receipt.status.sequence + 1,
-                  state: "unreachable",
-                  message: "The desktop execution is no longer reachable."
-                };
-                await save(receipt);
-              }
-            } catch {
+              const local = await readJson(join4(directory, "pairing.json"));
+              if (!local) return;
+              const discovered = await discoverProjects(observer);
+              if (discovered.find((p2) => p2.id === target.launch.destination.id)?.issue) return;
+              authorizedDestination(local, target.launch, discovered);
+              target.threadId = event.threadId;
+              target.phase = "released";
+              if (target.delivery) delete target.delivery.acknowledged;
+              await save(target);
+              await indexThreads();
+            } catch (error51) {
+              if (!(error51 instanceof DestinationAuthorizationError)) return;
+              target.phase = "failed";
+              target.failure = "The draft's saved project changed. Link the task from Codex using its task link.";
+              await save(target);
+              await indexThreads();
+              await unlink(path);
+              return;
             }
           }
-          if (networkError || deliveryBudget <= 0 || Date.now() - tickStarted > 5e3) continue;
+          if (target.threadId !== event.threadId) return;
+          if (applyObservation(target, event)) {
+            observe(target, Math.max(0, performance.timeOrigin + performance.now() - event.at));
+          }
+          await save(target);
+          await unlink(path);
+        });
+      });
+    };
+    let inspectionCursor = 0;
+    const inspect = async () => {
+      if (!observer || !journalHealthy) return;
+      const all = [...receipts.values()].filter(
+        (receipt) => receipt.threadId && (receipt.phase === "released" || owners.has(receipt.launch.id))
+      );
+      const batch = [];
+      for (let n2 = 0; n2 < all.length && batch.length < 4; n2++) {
+        const receipt = all[inspectionCursor++ % all.length];
+        if (performance.now() - (inspected.get(receipt.launch.id) ?? -Infinity) >= (receipt.status.state === "done" ? 3e4 : 5e3))
+          batch.push(receipt);
+      }
+      await mapConcurrent(
+        batch,
+        4,
+        (receipt) => writers.run(receipt.launch.id, async () => {
+          inspected.set(receipt.launch.id, performance.now());
           try {
-            if (receipt.phase === "drafted" && !acknowledged.has(receipt.launch.id)) {
-              deliveryBudget -= 1;
-              await post("draft-opened", {
-                launchId: receipt.launch.id,
-                ...receipt.draftOpenUncertain ? { uncertain: true } : {}
-              });
-              acknowledged.add(receipt.launch.id);
-            } else if (receipt.threadId && receipt.cwd) {
-              if (!acknowledged.has(receipt.launch.id)) {
-                deliveryBudget -= 1;
-                await post("receipt", {
-                  launchId: receipt.launch.id,
-                  threadId: receipt.threadId,
-                  cwd: receipt.cwd
-                });
-                acknowledged.add(receipt.launch.id);
-              }
-              if (deliveryBudget > 0 && reported.get(receipt.launch.id) !== receipt.status.sequence) {
-                deliveryBudget -= 1;
-                await post("status", { reports: [receipt.status] });
-                reported.set(receipt.launch.id, receipt.status.sequence);
-              }
-            } else if (receipt.failure && !acknowledged.has(receipt.launch.id)) {
-              deliveryBudget -= 1;
-              await post("failure", {
-                launchId: receipt.launch.id,
-                ambiguous: receipt.ambiguous ?? false,
-                message: receipt.failure
-              });
-              acknowledged.add(receipt.launch.id);
+            if (owners.has(receipt.launch.id) && receipt.phase !== "released") {
+              observe(receipt);
+              receipt.status.sequence++;
+              await save(receipt);
+              return;
             }
-          } catch (error51) {
-            networkError = error51;
-          }
-        }
-        if (networkError) throw networkError;
-        if (health.reachable && health.hooksReady && reconciled && Date.now() - tickStarted <= 5e3) {
-          const lookups = await post("thread-lookups", { cursor: watchCursor });
-          watchCursor = lookups.nextCursor;
-          for (const raw of lookups.watches) {
-            const watch = codexWatchSchema.parse(raw);
-            if (watch.machineId === machineId && !receipts.has(watch.id))
-              watched.set(watch.id, watch);
-          }
-          if (!lookupBusy) {
-            const request = lookups.requests.find(
-              (item) => Date.parse(item.expiresAt) > Date.now() + clockOffset
-            );
-            const watch = [...watched.values()].find(
-              (item) => Date.now() - (watchAttempts.get(item.id) ?? 0) > 3e4
+            const { data } = await observer.call(
+              "thread/turns/list",
+              { threadId: receipt.threadId, limit: 1, itemsView: "notLoaded" },
+              2e3
             );
-            if (request || watch) {
-              lookupBusy = true;
-              if (!request && watch) watchAttempts.set(watch.id, Date.now());
-              lookupWork = (async () => {
-                const local = await readJson(join4(directory, "pairing.json"));
-                if (!local) throw new Error("The local connection is unavailable");
-                const server = await connectLookup();
-                if (request) {
-                  const result = await lookupService.lookup(server, request, local, catalog2);
-                  lookupResults.push({ id: request.id, ...result, error: null });
-                } else if (watch) {
-                  watchResults.push(await linkedReceipt(server, watch, local, catalog2));
-                  watched.delete(watch.id);
-                }
-              })().catch(() => {
-                lookupServer?.close();
-                lookupServer = void 0;
-                if (request)
-                  lookupResults.push({
-                    id: request.id,
-                    results: [],
-                    hasMore: false,
-                    error: "The local task could not be read. Check Codex and the saved project, then try again."
-                  });
-              }).finally(() => {
-                lookupBusy = false;
+            const turn = data[0];
+            const matchesActive = receipt.status.state !== "running" || turn?.id === receipt.status.turnId;
+            const alive = await observedProcessAlive(receipt.pid, receipt.nativeIdentity);
+            if (turn && ["completed", "failed"].includes(turn.status) && matchesActive && !receipt.status.waiting) {
+              receipt.status = {
+                ...receipt.status,
+                state: "done",
+                waiting: false,
+                turnId: turn.id,
+                message: turn.status === "failed" ? "Codex ended this turn with an error. Open the task for details." : null
+              };
+              observe(receipt);
+            } else if ((receipt.handoffWaiting || receipt.hookAt && alive) && receipt.status.state === "running") {
+              observe(receipt);
+            } else {
+              receipt.status = {
+                ...receipt.status,
+                state: "unreachable",
+                message: "The task\u2019s current execution state could not be verified. Open it in Codex."
+              };
+              observe(receipt);
+            }
+            receipt.status.sequence++;
+            await save(receipt);
+          } catch {
+            observer?.close();
+            observer = void 0;
+          }
+        })
+      );
+    };
+    let deliveryCursor = 0;
+    const deliver = async () => {
+      if (!clockAnchor) return;
+      const all = [...receipts.values()];
+      const batch = [];
+      for (let n2 = 0; n2 < all.length && batch.length < 4; n2++) {
+        const receipt = all[deliveryCursor++ % all.length];
+        const kind = receipt.threadId && receipt.cwd ? "receipt" : receipt.phase === "drafted" ? "draft" : receipt.failure ? "failure" : void 0;
+        if (kind && retryReady(receipt.delivery?.retry) && (receipt.delivery?.acknowledged !== kind || kind === "receipt" && receipt.delivery?.sequence !== receipt.status.sequence))
+          batch.push(receipt);
+      }
+      await mapConcurrent(batch, 4, async (receipt) => {
+        const snapshot = await writers.run(receipt.launch.id, async () => structuredClone(receipt));
+        const snapshotAt = performance.now();
+        const observation2 = observations.get(receipt.launch.id);
+        const observationAge = observation2 && observation2.wall === snapshot.observedAt ? Math.max(0, snapshotAt - observation2.monotonic) : 9e4;
+        const delivery = snapshot.delivery ?? {};
+        try {
+          if (snapshot.threadId && snapshot.cwd) {
+            if (delivery.acknowledged !== "receipt") {
+              await post("receipt", {
+                launchId: snapshot.launch.id,
+                threadId: snapshot.threadId,
+                cwd: snapshot.cwd
               });
+              delivery.acknowledged = "receipt";
             }
+            if (delivery.sequence !== snapshot.status.sequence) {
+              await post("status", {
+                reports: [
+                  {
+                    ...snapshot.status,
+                    ...supportsFreshness ? {
+                      observationAgeMs: Math.ceil(
+                        observationAge + Math.max(0, performance.now() - snapshotAt)
+                      )
+                    } : {}
+                  }
+                ]
+              });
+              delivery.sequence = snapshot.status.sequence;
+            }
+          } else if (snapshot.phase === "drafted") {
+            await post("draft-opened", {
+              launchId: snapshot.launch.id,
+              ...snapshot.draftOpenUncertain ? { uncertain: true } : {}
+            });
+            delivery.acknowledged = "draft";
+          } else if (snapshot.failure) {
+            await post("failure", {
+              launchId: snapshot.launch.id,
+              ambiguous: snapshot.ambiguous ?? false,
+              message: snapshot.failure
+            });
+            delivery.acknowledged = "failure";
+          }
+          delete delivery.retry;
+          delivery.lastSuccessAt = Date.now();
+        } catch (error51) {
+          delivery.retry = retryFailure(error51, delivery.retry);
+          if (error51 instanceof KernelConnectionError && error51.fatal) {
+            stopping = true;
+            fatalError = error51.message;
           }
-          const response = await post("launches", {});
-          for (const launch of response.launches) await begin(codexLaunchSchema.parse(launch));
         }
-      } catch (error51) {
-        if (error51 instanceof KernelConnectionError && [401, 403].includes(error51.status)) {
-          process.stdout.write(
-            "The machine pairing is no longer authorized. The companion has stopped.\n"
-          );
-          return;
+        await writers.run(receipt.launch.id, async () => {
+          if (delivery.acknowledged === "draft" && receipt.threadId) delete delivery.acknowledged;
+          receipt.delivery = delivery;
+          await save(receipt);
+        });
+      });
+      for (let i2 = lookupResults.length - 1; i2 >= 0; i2--) {
+        const id = lookupResults[i2].id;
+        if ((lookupExpiries.get(id) ?? 0) <= kernelNow()) {
+          lookupResults.splice(i2, 1);
+          lookupRetries.delete(id);
+          lookupExpiries.delete(id);
+        }
+      }
+      const pending = lookupResults.filter((result) => retryReady(lookupRetries.get(result.id))).slice(0, 4);
+      for (const result of pending) lookupResults.splice(lookupResults.indexOf(result), 1);
+      for (const result of pending) {
+        try {
+          await post("thread-lookup-result", result);
+        } catch (error51) {
+          const retry = retryFailure(error51, lookupRetries.get(result.id));
+          lookupRetries.set(result.id, retry);
+          if (!retry.blocked) lookupResults.push(result);
+          else
+            await writeJson(join4(directory, "blocked-lookups", `${result.id}.json`), {
+              id: result.id,
+              ...retry.blocked
+            });
+          if (error51 instanceof KernelConnectionError && error51.fatal) throw error51;
         }
       }
-      await delay(2e3, void 0, { signal }).catch(() => void 0);
+    };
+    const lookups = async () => {
+      if (!health.reachable || !health.hooksReady || !refreshed || lookupBusy) return;
+      const response = await post("thread-lookups", { cursor: watchCursor });
+      watchCursor = response.nextCursor;
+      for (const request2 of response.requests)
+        lookupExpiries.set(request2.id, Date.parse(request2.expiresAt));
+      for (const raw of response.watches) {
+        const watch2 = codexWatchSchema.parse(raw);
+        if (watch2.machineId === machineId && !receipts.has(watch2.id) && !blocked.has(watch2.id))
+          watched.set(watch2.id, watch2);
+      }
+      const request = response.requests.find((item) => Date.parse(item.expiresAt) > kernelNow());
+      const watch = [...watched.values()].find(
+        (item) => performance.now() - (watchAttempts.get(item.id) ?? -Infinity) > 3e4
+      );
+      if (!request && !watch) return;
+      lookupBusy = true;
+      if (!request && watch) watchAttempts.set(watch.id, performance.now());
+      lookupWork = (async () => {
+        const local = await readJson(join4(directory, "pairing.json"));
+        if (!local) throw new Error("The local connection is unavailable");
+        const server = await connectLookup();
+        if (request) {
+          const result = await deadline(
+            lookupService.lookup(server, request, local, catalog2),
+            25e3
+          );
+          lookupResults.push({ id: request.id, ...result, error: null });
+        } else if (watch) {
+          watchResults.push(await linkedReceipt(server, watch, local, catalog2));
+          watched.delete(watch.id);
+        }
+      })().catch(() => {
+        lookupServer?.close();
+        lookupServer = void 0;
+        if (request)
+          lookupResults.push({
+            id: request.id,
+            results: [],
+            hasMore: false,
+            error: "The local task could not be read. Check Codex and the saved project, then try again."
+          });
+      }).finally(() => {
+        lookupBusy = false;
+      });
+    };
+    const launches = async () => {
+      if (!journalHealthy || !health.reachable || !health.hooksReady || !refreshed || performance.now() - refreshed >= 3e4 || !observer)
+        return;
+      const response = await post("launches", {});
+      await mapConcurrent(response.launches, 4, (raw) => {
+        const launch = codexLaunchSchema.parse(raw);
+        return writers.run(launch.id, () => begin(launch)).then(
+          () => schedule("events", 0, async () => {
+            await localEvents();
+            schedule("delivery", 0, deliver);
+          })
+        );
+      });
+    };
+    const diagnostics = async () => {
+      const pending = [...receipts.values()].filter((r2) => {
+        const kind = r2.threadId && r2.cwd ? "receipt" : r2.phase === "drafted" ? "draft" : r2.failure ? "failure" : void 0;
+        return kind && (r2.delivery?.acknowledged !== kind || kind === "receipt" && r2.delivery?.sequence !== r2.status.sequence);
+      });
+      const successes = [...receipts.values()].flatMap(
+        (r2) => r2.delivery?.lastSuccessAt ? [r2.delivery.lastSuccessAt] : []
+      );
+      await writeJson(join4(directory, "recovery.json"), {
+        lastSuccessfulDelivery: successes.length ? Math.max(...successes) : null,
+        pending: pending.filter((r2) => !r2.delivery?.retry?.blocked).length,
+        blocked: blocked.size + [...receipts.values()].filter(
+          (r2) => r2.delivery?.retry?.blocked || r2.reconciliation?.blocked
+        ).length + (await entries(join4(directory, "blocked-lookups"))).length,
+        oldestPendingAt: pending.length ? Math.min(...pending.map((r2) => r2.delivery?.retry?.pendingSince ?? r2.preparedAt)) : null,
+        issue: fatalError ?? [...laneErrors.values()][0] ?? null,
+        failures: [...blocked].map((launchId) => ({
+          launchId,
+          code: "invalid_receipt",
+          message: "A damaged receipt was isolated for local recovery. This launch will not be repeated."
+        })).concat(
+          [...receipts.values()].filter((r2) => r2.delivery?.retry?.blocked || r2.reconciliation?.blocked).map((r2) => ({
+            launchId: r2.launch.id,
+            ...r2.delivery?.retry?.blocked ?? r2.reconciliation?.blocked
+          }))
+        )
+      });
+    };
+    persistDiagnostics = diagnostics;
+    while (!signal.aborted && !stopping) {
+      schedule("catalog", 1e4, async () => {
+        await refreshCatalog();
+        schedule("heartbeat", 0, heartbeat);
+      });
+      schedule("heartbeat", heartbeatHealth === JSON.stringify(health) ? 1e4 : 0, heartbeat);
+      schedule("events", 0, localEvents);
+      schedule("reconciliation", 2e3, reconcile);
+      schedule("observation", 2e3, inspect);
+      schedule("delivery", 0, deliver);
+      schedule("lookups", 2e3, lookups);
+      schedule("launches", 2e3, launches);
+      schedule("diagnostics", 2e3, diagnostics);
+      await lanes.settle();
+      await delay(250, void 0, { signal }).catch(() => void 0);
     }
   } finally {
+    stopping = true;
     await Promise.allSettled([...owners.values()].map((server) => server.stop()));
     await observer?.stop().catch(() => void 0);
+    await catalogServer?.stop().catch(() => void 0);
     await lookupServer?.stop().catch(() => void 0);
+    await lanes?.drain();
     await lookupWork;
+    await Promise.allSettled(
+      [
+        ...owners.values(),
+        ...observer ? [observer] : [],
+        ...catalogServer ? [catalogServer] : [],
+        ...lookupServer ? [lookupServer] : []
+      ].map((server) => server.stop())
+    );
+    await persistDiagnostics?.().catch(() => void 0);
     await unlock();
   }
 }
@@ -23580,7 +24064,7 @@ import { setTimeout as delay2 } from "node:timers/promises";
 import { createInterface } from "node:readline/promises";
 
 // src/setup.ts
-import { chmod as chmod2, copyFile, mkdir as mkdir4, rename as rename2, rm } from "node:fs/promises";
+import { chmod as chmod2, copyFile, mkdir as mkdir4, rename as rename3, rm } from "node:fs/promises";
 import { homedir as homedir4 } from "node:os";
 import { dirname as dirname2, join as join6, resolve as resolve2 } from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
@@ -23592,7 +24076,7 @@ async function installBundle(entrypoint2) {
     try {
       await copyFile(entrypoint2, temporary);
       await chmod2(temporary, 448);
-      await rename2(temporary, installedEntrypoint);
+      await rename3(temporary, installedEntrypoint);
     } finally {
       await rm(temporary, { force: true });
     }
@@ -23639,12 +24123,12 @@ async function installService(id) {
 
 // src/onboarding.ts
 async function waitForStoppedCompanion(directory) {
-  const deadline = Date.now() + 2e4;
+  const deadline2 = Date.now() + 2e4;
   for (; ; ) {
     try {
       return await processLock(directory);
     } catch (error51) {
-      if (Date.now() >= deadline) throw error51;
+      if (Date.now() >= deadline2) throw error51;
       await delay2(200);
     }
   }
@@ -23771,10 +24255,11 @@ async function connectCodex(entrypoint2) {
   else process.stdout.write("Choose your project mapping in Kernel \u2192 Integrations \u2192 Codex.\n");
 }
 async function status() {
-  const profile = await signedInProfile();
-  process.stdout.write(`Signed in: ${profile.session.account}
+  const profile = await readProfile();
+  if (!profile?.session) throw new Error("Run krnl login first");
+  process.stdout.write(`Account: ${profile.session.account} (saved locally)
 `);
-  const id = profile.session.machineId;
+  const id = profile.session.machineId ?? profile.pendingMachineId;
   if (!id) {
     process.stdout.write("Codex is not connected. Run krnl connect codex.\n");
     return;
@@ -23793,6 +24278,32 @@ Saved projects: ${health.projects}
     if (health.health.issue) process.stdout.write(`${health.health.issue}
 `);
   }
+  const recovery = await readJson(join7(pairingDirectory(id), "recovery.json"));
+  if (recovery) {
+    process.stdout.write(
+      `Pending deliveries: ${recovery.pending} \xB7 Blocked: ${recovery.blocked}
+`
+    );
+    if (recovery.lastSuccessfulDelivery)
+      process.stdout.write(
+        `Last successful delivery: ${new Date(recovery.lastSuccessfulDelivery).toISOString()}
+`
+      );
+    if (recovery.oldestPendingAt)
+      process.stdout.write(
+        `Oldest pending delivery: ${Math.max(0, Math.floor((Date.now() - recovery.oldestPendingAt) / 1e3))} seconds
+`
+      );
+    if (recovery.issue) process.stdout.write(`${recovery.issue}
+`);
+    for (const failure of recovery.failures)
+      process.stdout.write(`${failure.launchId}: ${failure.message}
+`);
+    if (recovery.blocked)
+      process.stdout.write(
+        "Blocked receipts remain on this Mac. Do not remove them or repeat their launches; use the existing Codex task while repairing the connection.\n"
+      );
+  }
 }
 async function disconnect(logout = false) {
   const profile = await readProfile();
@@ -23907,7 +24418,7 @@ async function main() {
   }
   if (command === "--version") {
     process.stdout.write(
-      `${false ? "development" : "0.1.4"}
+      `${false ? "development" : "0.1.5"}
 `
     );
     return;