@supercorks/krnl 0.1.0 → 0.1.2

package/README.md

@@ -1,7 +1,7 @@
 # Kernel CLI
 
-Connect [Kernel](https://app.krnl.work) to Codex on your Mac. Start a task from Kernel in Plan or
-Work mode, then open the same task in Codex. Conversations and approvals stay in Codex; Kernel
+Connect [Kernel](https://app.krnl.work) to Codex on your Mac. Choose **Launch in Codex** on a Kernel task, review Plan/Work mode, destination, model, reasoning,
+and folder options in the popup, then open the same task in Codex. Conversations and approvals stay in Codex; Kernel
 shows execution status and a direct link.
 
 ## Install and connect
@@ -14,6 +14,8 @@ krnl login
 krnl connect codex
 ```
 
+If pnpm reports `ERR_PNPM_NO_GLOBAL_BIN_DIR`, run `pnpm setup`, open a new Terminal tab, and retry the install.
+
 `krnl login` opens Kernel in your default browser. Sign in with your invited Kernel account and
 choose **Connect CLI**. Return to Terminal when the browser says the login is finishing.
 
@@ -24,8 +26,12 @@ instructions if the new hooks need review. Review the eight Kernel hooks and res
 tasks afterward. The companion detects completed review automatically.
 
 Open **Settings → Integrations → Codex** in Kernel to map an organization or project to a saved
-Codex project. Your Mac and saved projects appear automatically. Launches stay disabled until setup
-is ready; one unavailable project does not disable healthy projects.
+Codex project. Your Mac and saved projects appear automatically. Each connection card contains its organization and
+project mappings. Choose **Add mapping** or **Edit** to set the destination, model, and reasoning.
+New mappings default to **GPT-6 Astra · xhigh**; choices come from that Mac’s current Codex model
+catalog. Launches stay disabled until setup is ready; one unavailable project does not disable
+healthy projects. **Delete connection** revokes its authorization and removes its mappings, while
+keeping existing tasks, handoff history, receipts, and worktrees.
 
 No repository checkout, build tools, copied IDs, or per-folder authorization commands are needed.
 Installing the npm package alone does not start a service or change Codex configuration.
@@ -50,6 +56,10 @@ pnpm add -g @supercorks/krnl@latest
 krnl connect codex
 ```
 
+Version **0.1.1 or later** is required to launch with mapping model and reasoning settings.
+Version **0.1.2 or later** also supports linking an existing Codex task.
+Kernel explains when an older companion needs this update; existing task monitoring continues.
+
 Repeated connection reuses the machine identity. Review changed hook commands in `/hooks` if Node
 moved. After updating Node, run `krnl connect codex` to refresh the service’s executable path.
 
@@ -74,6 +84,26 @@ Existing companion installations keep their allowlist until you explicitly upgra
 `krnl login` and `krnl connect codex`. The upgrade retains their machine identity, mappings, and
 handoff history when the existing connection is still authorized.
 
+## Link an existing task
+
+On a Kernel task, choose **Link existing task**. Search by the current Codex task title
+(at least three characters) or paste a `codex://threads/<task-id>` link, select the match,
+and choose **Link task**. Choose a Mac if more than one is connected. Only tasks in
+compatible, locally authorized saved projects appear. Archived tasks are labeled.
+
+Linking adds monitoring and a direct Codex link; it never starts a turn, changes its model,
+or changes its folder. A Codex task can be associated with one Kernel task per Mac;
+linking it again to that same task returns the existing association.
+
+Search uses a short-lived local metadata cache and never searches messages or previews.
+Kernel receives at most 25 matching titles and destination metadata per lookup. Searches
+expire after 30 seconds, with resolved matches available for two minutes. Refine a broad
+query or paste a deep link if the catalog cannot be searched in time.
+
+Completed tasks become Done after their saved turn metadata is checked. A task already
+executing or awaiting input when linked can remain Disconnected until its next status hook;
+continue in Codex normally. Subsequent hooks provide Running, waiting, and Done transitions.
+
 ## Local data and troubleshooting
 
 The executable is copied to a stable location under
@@ -91,7 +121,7 @@ revoked the Mac remotely, sign in again with `krnl login` before reconnecting. I
 reach Kernel, the disconnect command stops the local service and asks you to retry online.
 
 Disconnect and logout preserve Codex tasks, local creation receipts, and worktrees. Hooks retain
-only lifecycle metadata for tasks created by this connection. Neither transcripts nor attachment
+only lifecycle metadata for tasks launched or explicitly linked through this connection. Neither transcripts nor attachment
 contents are uploaded. Keep receipts intact when investigating an uncertain launch; the companion
 will reconcile creation before retrying an acknowledgement and will not repeat an uncertain turn.
 

package/dist/kernel-companion.mjs

@@ -12425,12 +12425,12 @@ function describe(description) {
   return ch;
 }
 // @__NO_SIDE_EFFECTS__
-function meta(metadata) {
+function meta(metadata2) {
   const ch = new $ZodCheck({ check: "meta" });
   ch._zod.onattach = [
     (inst) => {
       const existing = globalRegistry.get(inst) ?? {};
-      globalRegistry.add(inst, { ...existing, ...metadata });
+      globalRegistry.add(inst, { ...existing, ...metadata2 });
     }
   ];
   ch._zod.check = () => {
@@ -15659,15 +15659,15 @@ async function writeJson(path, value) {
 async function processLock(directory) {
   const port = 4e4 + createHash("sha256").update(directory).digest().readUInt16BE(0) % 2e4;
   const server = createServer((socket) => socket.destroy());
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     server.once(
       "error",
       () => reject(new Error("A companion already owns this pairing, or its local lock port is in use"))
     );
-    server.listen({ host: "127.0.0.1", port, exclusive: true }, resolve2);
+    server.listen({ host: "127.0.0.1", port, exclusive: true }, resolve3);
   });
   return async () => {
-    await new Promise((resolve2) => server.close(() => resolve2()));
+    await new Promise((resolve3) => server.close(() => resolve3()));
   };
 }
 function processAlive(pid) {
@@ -15710,12 +15710,12 @@ async function readCredential(id, keychainService = service) {
 async function saveCredential(id, token, keychainService = service) {
   external_exports.uuid().parse(id);
   external_exports.string().regex(/^[A-Za-z0-9_-]{43,128}$/).parse(token);
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const child = spawn("/usr/bin/security", ["-i"], { stdio: ["pipe", "ignore", "ignore"] });
     child.on("error", reject);
     child.on(
       "exit",
-      (code) => code === 0 ? resolve2() : reject(new Error("Keychain could not save the machine credential"))
+      (code) => code === 0 ? resolve3() : reject(new Error("Keychain could not save the machine credential"))
     );
     child.stdin.end(`add-generic-password -U -s "${keychainService}" -a "${id}" -w "${token}"
 `);
@@ -16016,12 +16016,12 @@ var AppServer = class extends EventEmitter {
   call(method, params, timeoutMs = 3e4) {
     if (this.closed) return Promise.reject(new Error("Codex connection closed"));
     const id = ++this.nextId;
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
         reject(new Error(`Codex ${method} acknowledgement is uncertain`));
       }, timeoutMs);
-      this.pending.set(id, { resolve: (value) => resolve2(value), reject, timer });
+      this.pending.set(id, { resolve: (value) => resolve3(value), reject, timer });
       this.child.stdin.write(JSON.stringify({ id, method, params }) + "\n");
     });
   }
@@ -16041,11 +16041,11 @@ var AppServer = class extends EventEmitter {
       this.close();
       return;
     }
-    await new Promise((resolve2, reject) => {
+    await new Promise((resolve3, reject) => {
       const finish = () => {
         clearTimeout(escalate);
         clearTimeout(deadline);
-        resolve2();
+        resolve3();
       };
       const escalate = setTimeout(() => this.child.kill("SIGKILL"), 3e3);
       const deadline = setTimeout(() => {
@@ -22061,6 +22061,25 @@ var reconcileTogglEntrySchema = external_exports.discriminatedUnion("action", [
 
 // ../domain/src/codex.ts
 var CODEX_PROTOCOL_VERSION = 1;
+var CODEX_DEFAULT_MODEL = "gpt-6-astra";
+var CODEX_DEFAULT_REASONING_EFFORT = "xhigh";
+var CODEX_REASONING_EFFORTS = [
+  "none",
+  "minimal",
+  "low",
+  "medium",
+  "high",
+  "xhigh",
+  "max",
+  "ultra"
+];
+var codexReasoningEffortSchema = external_exports.enum(CODEX_REASONING_EFFORTS);
+var codexModelIdSchema = external_exports.string().trim().min(1).max(200).regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/);
+var codexModelSchema = external_exports.strictObject({
+  id: codexModelIdSchema,
+  label: external_exports.string().trim().min(1).max(200),
+  reasoningEfforts: external_exports.array(codexReasoningEffortSchema).min(1).max(CODEX_REASONING_EFFORTS.length)
+});
 var protocolVersion = external_exports.literal(CODEX_PROTOCOL_VERSION);
 var sequence = external_exports.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
 var identity = external_exports.string().min(1).max(200);
@@ -22078,6 +22097,10 @@ var codexCatalogProjectSchema = external_exports.strictObject({
 var codexHealthSchema = external_exports.strictObject({
   reachable: external_exports.boolean(),
   hooksReady: external_exports.boolean(),
+  // Older companions cannot parse model settings in strict launch payloads.
+  supportsModelSelection: external_exports.boolean().optional(),
+  supportsThreadLinking: external_exports.boolean().optional(),
+  models: external_exports.array(codexModelSchema).max(100).optional(),
   appServerVersion: external_exports.string().max(100),
   desktopVersion: external_exports.string().max(100),
   issue: external_exports.string().max(500).nullable()
@@ -22103,6 +22126,8 @@ var saveCodexMappingSchema = external_exports.strictObject({
   machineId: external_exports.uuid(),
   projectId: identity,
   checkout: codexCheckoutSchema,
+  model: codexModelIdSchema.default(CODEX_DEFAULT_MODEL),
+  reasoningEffort: codexReasoningEffortSchema.default(CODEX_DEFAULT_REASONING_EFFORT),
   version: sequence.default(0)
 });
 var deleteCodexMappingSchema = external_exports.strictObject({
@@ -22116,6 +22141,9 @@ var launchCodexTaskSchema = external_exports.strictObject({
   taskId: external_exports.uuid(),
   taskVersion: external_exports.number().int().positive(),
   mode: codexModeSchema,
+  model: codexModelIdSchema.optional(),
+  reasoningEffort: codexReasoningEffortSchema.optional(),
+  checkout: codexCheckoutSchema.optional(),
   override: external_exports.strictObject({ machineId: external_exports.uuid(), projectId: identity }).optional()
 });
 var codexLaunchSchema = external_exports.strictObject({
@@ -22125,6 +22153,8 @@ var codexLaunchSchema = external_exports.strictObject({
   mode: codexModeSchema,
   destination: codexCatalogProjectSchema,
   checkout: codexCheckoutSchema,
+  model: codexModelIdSchema.optional(),
+  reasoningEffort: codexReasoningEffortSchema.optional(),
   submittedAt: external_exports.iso.datetime(),
   expiresAt: external_exports.iso.datetime(),
   task: external_exports.strictObject({
@@ -22196,6 +22226,83 @@ function codexLaunchPrompt(launch) {
   ].join("\n");
 }
 
+// ../domain/src/codex-threads.ts
+var CODEX_THREAD_SEARCH_MIN = 3;
+var CODEX_THREAD_RESULT_LIMIT = 25;
+var codexTitleQuerySchema = external_exports.string().trim().max(200).refine(
+  (value) => [...value].length >= CODEX_THREAD_SEARCH_MIN,
+  "Enter at least 3 characters to search task titles"
+);
+function codexThreadIdFromUrl(value) {
+  try {
+    if (!/^codex:\/\/threads\/[0-9a-f-]+\/?$/i.test(value.trim())) return null;
+    const url2 = new URL(value.trim());
+    if (url2.protocol !== "codex:" || url2.hostname !== "threads" || url2.port || url2.username || url2.password || url2.search || url2.hash)
+      return null;
+    const match = /^\/([^/]+)\/?$/.exec(url2.pathname);
+    const id = external_exports.uuid().safeParse(match?.[1]);
+    return id.success ? id.data.toLowerCase() : null;
+  } catch {
+    return null;
+  }
+}
+var base = {
+  protocolVersion: external_exports.literal(1),
+  requestId: external_exports.uuid(),
+  taskId: external_exports.uuid(),
+  machineId: external_exports.uuid()
+};
+var startCodexThreadLookupSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.strictObject({ ...base, kind: external_exports.literal("search"), query: codexTitleQuerySchema }),
+  external_exports.strictObject({
+    ...base,
+    kind: external_exports.literal("link"),
+    url: external_exports.string().trim().max(200).refine(
+      (value) => codexThreadIdFromUrl(value) !== null,
+      "Paste a codex://threads/<task-id> link"
+    )
+  })
+]);
+var codexThreadResultSchema = external_exports.strictObject({
+  id: external_exports.uuid(),
+  title: external_exports.string().trim().min(1).max(300),
+  project: codexCatalogProjectSchema,
+  cwd: external_exports.string().min(1).max(4096),
+  updatedAt: external_exports.iso.datetime(),
+  archived: external_exports.boolean()
+});
+var codexThreadLookupWorkSchema = external_exports.strictObject({
+  id: external_exports.uuid(),
+  query: codexTitleQuerySchema.nullable(),
+  threadId: external_exports.uuid().nullable(),
+  expiresAt: external_exports.iso.datetime()
+}).refine(
+  (value) => value.query === null !== (value.threadId === null),
+  "Choose title search or a task link"
+);
+var codexThreadLookupResultSchema = external_exports.strictObject({
+  protocolVersion: external_exports.literal(1),
+  connectionId: external_exports.uuid(),
+  generation: external_exports.number().int().nonnegative(),
+  id: external_exports.uuid(),
+  results: external_exports.array(codexThreadResultSchema).max(CODEX_THREAD_RESULT_LIMIT),
+  hasMore: external_exports.boolean(),
+  error: external_exports.string().max(500).nullable()
+});
+var linkCodexThreadSchema = external_exports.strictObject({
+  ...base,
+  lookupId: external_exports.uuid(),
+  threadId: external_exports.uuid()
+});
+var codexWatchSchema = external_exports.strictObject({
+  id: external_exports.uuid(),
+  machineId: external_exports.uuid(),
+  sequence: external_exports.number().int().nonnegative(),
+  linkedThreadId: external_exports.uuid(),
+  title: external_exports.string().min(1).max(300),
+  destination: codexCatalogProjectSchema
+});
+
 // ../domain/src/cli.ts
 var CLI_PROTOCOL_VERSION = 1;
 var CLI_LOGIN_TTL_MS = 5 * 6e4;
@@ -22269,6 +22376,257 @@ var settingsHealthSnapshotSchema = external_exports.object({
   })
 });
 
+// src/models.ts
+var messages = {
+  catalog: "Codex's model catalog could not be read. Reconnect the companion and try again.",
+  model: "The selected model is unavailable on this Mac. Choose another model in Codex settings.",
+  effort: "The selected model does not support this reasoning effort. Update the Codex settings and try again."
+};
+var CodexModelSelectionError = class extends Error {
+  constructor(reason) {
+    super(messages[reason]);
+  }
+};
+var modelPageSchema = external_exports.object({
+  data: external_exports.array(
+    external_exports.object({
+      model: codexModelIdSchema,
+      displayName: external_exports.string().trim().min(1),
+      supportedReasoningEfforts: external_exports.array(external_exports.object({ reasoningEffort: external_exports.string() }))
+    })
+  ),
+  nextCursor: external_exports.string().min(1).nullable().optional()
+});
+async function discoverModels(server) {
+  try {
+    const models = /* @__PURE__ */ new Map();
+    const cursors = /* @__PURE__ */ new Set();
+    let cursor;
+    do {
+      const page = modelPageSchema.parse(
+        await server.call("model/list", { limit: 100, ...cursor ? { cursor } : {} }, 5e3)
+      );
+      for (const model of page.data) {
+        const reasoningEfforts = model.supportedReasoningEfforts.flatMap((option) => {
+          const parsed = codexReasoningEffortSchema.safeParse(option.reasoningEffort);
+          return parsed.success ? [parsed.data] : [];
+        });
+        if (!reasoningEfforts.length) continue;
+        models.set(model.model, {
+          id: model.model,
+          label: model.displayName.slice(0, 200),
+          reasoningEfforts: [...new Set(reasoningEfforts)]
+        });
+        if (models.size > 100) throw new CodexModelSelectionError("catalog");
+      }
+      cursor = page.nextCursor ?? void 0;
+      if (cursor) {
+        if (cursors.has(cursor) || cursors.size >= 100)
+          throw new CodexModelSelectionError("catalog");
+        cursors.add(cursor);
+      }
+    } while (cursor);
+    return [...models.values()];
+  } catch {
+    throw new CodexModelSelectionError("catalog");
+  }
+}
+function resolveModelSelection(launch, models) {
+  const model = launch.model ?? CODEX_DEFAULT_MODEL;
+  const reasoningEffort = launch.reasoningEffort ?? CODEX_DEFAULT_REASONING_EFFORT;
+  const available = models.find((candidate) => candidate.id === model);
+  if (!available) throw new CodexModelSelectionError("model");
+  if (!available.reasoningEfforts.includes(reasoningEffort))
+    throw new CodexModelSelectionError("effort");
+  return { model, reasoningEffort };
+}
+
+// src/threads.ts
+import { realpath as realpath2, stat as stat2 } from "node:fs/promises";
+import { isAbsolute as isAbsolute2, relative, resolve } from "node:path";
+var metadata = external_exports.object({
+  id: external_exports.uuid(),
+  name: external_exports.string().nullable().optional(),
+  projectId: external_exports.string().nullable().optional(),
+  cwd: external_exports.string(),
+  updatedAt: external_exports.number().finite().nonnegative()
+});
+var pageSchema = external_exports.object({
+  data: external_exports.array(metadata).max(200),
+  nextCursor: external_exports.string().nullable().optional()
+});
+var sourceKinds = [
+  "cli",
+  "vscode",
+  "exec",
+  "appServer",
+  "subAgent",
+  "subAgentReview",
+  "subAgentCompact",
+  "subAgentThreadSpawn",
+  "subAgentOther",
+  "unknown"
+];
+var inside = (root, folder) => {
+  const path = relative(root, folder);
+  return !isAbsolute2(path) && path !== ".." && !path.startsWith("../");
+};
+async function commonGitDirectory(folder) {
+  try {
+    const { stdout } = await execute("git", ["-C", folder, "rev-parse", "--git-common-dir"], {
+      timeout: 1500,
+      maxBuffer: 8192
+    });
+    return await realpath2(resolve(folder, stdout.trim()));
+  } catch {
+    return null;
+  }
+}
+async function resolveThreadProject(thread, pairing, catalog2) {
+  const authorized = catalog2.filter(
+    (project) => !project.issue && (pairing.projectAccess === "all-saved" || pairing.projects.some(
+      (allowed) => allowed.id === project.id && allowed.root === project.root
+    ))
+  );
+  let cwd;
+  try {
+    cwd = await realpath2(thread.cwd);
+    if (!(await stat2(cwd)).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 realpath2(project.root).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) {
+      if (project.isGit && await commonGitDirectory(project.root) === common)
+        return { project, cwd };
+    }
+  return null;
+}
+var CodexThreadLookupService = class {
+  constructor(now = () => performance.now()) {
+    this.now = now;
+  }
+  now;
+  cached = null;
+  refreshedAt = 0;
+  loading;
+  index(server) {
+    if (this.cached && this.now() - this.refreshedAt < 3e4) return Promise.resolve(this.cached);
+    if (this.loading) return this.loading;
+    this.loading = (async () => {
+      const threads = [];
+      const started = this.now();
+      for (const archived of [false, true]) {
+        let cursor = null;
+        const visited = /* @__PURE__ */ new Set();
+        do {
+          if (this.now() - started > 2e4 || threads.length > 5e4)
+            throw new Error(
+              "The task catalog is too large to search right now. Paste a Codex task link instead."
+            );
+          const page = pageSchema.parse(
+            await server.call(
+              "thread/list",
+              {
+                limit: 200,
+                archived,
+                modelProviders: [],
+                sourceKinds,
+                useStateDbOnly: true,
+                sortKey: "updated_at",
+                ...cursor ? { cursor } : {}
+              },
+              5e3
+            )
+          );
+          threads.push(...page.data.map((thread) => ({ ...thread, archived })));
+          cursor = page.nextCursor ?? null;
+          if (cursor && visited.has(cursor))
+            throw new Error("Codex returned an invalid task catalog. Try again.");
+          if (cursor) visited.add(cursor);
+        } while (cursor);
+      }
+      this.cached = [...new Map(threads.map((thread) => [thread.id, thread])).values()].sort(
+        (a2, b2) => b2.updatedAt - a2.updatedAt || a2.id.localeCompare(b2.id)
+      );
+      this.refreshedAt = this.now();
+      return this.cached;
+    })().finally(() => {
+      this.loading = void 0;
+    });
+    return this.loading;
+  }
+  async lookup(server, raw, pairing, catalog2) {
+    const work = codexThreadLookupWorkSchema.parse(raw);
+    let candidates;
+    if (work.threadId) {
+      const result = external_exports.object({ thread: metadata }).parse(
+        await server.call("thread/read", { threadId: work.threadId, includeTurns: false }, 5e3)
+      );
+      if (result.thread.id !== work.threadId) throw new Error("Codex returned a different task.");
+      candidates = [{ ...result.thread, archived: false }];
+    } else {
+      const query = work.query.toLowerCase();
+      candidates = (await this.index(server)).filter(
+        (thread) => thread.name?.trim().slice(0, 300).toLowerCase().includes(query)
+      );
+    }
+    const results = [];
+    const started = this.now();
+    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);
+      if (!destination) continue;
+      if (results.length === CODEX_THREAD_RESULT_LIMIT) return { results, hasMore: true };
+      results.push({
+        id: thread.id,
+        title: thread.name?.trim().slice(0, 300) || "Untitled task",
+        ...destination,
+        updatedAt: new Date(thread.updatedAt * 1e3).toISOString(),
+        archived: thread.archived
+      });
+    }
+    return { results, hasMore: false };
+  }
+};
+async function linkedReceipt(server, watch, pairing, catalog2) {
+  if (watch.machineId !== pairing.machineId)
+    throw new Error("This task belongs to another machine");
+  const { thread } = external_exports.object({ thread: metadata }).parse(
+    await server.call(
+      "thread/read",
+      { threadId: watch.linkedThreadId, includeTurns: false },
+      5e3
+    )
+  );
+  if (thread.id !== watch.linkedThreadId) throw new Error("Codex returned a different task");
+  const destination = await resolveThreadProject(thread, pairing, catalog2);
+  if (!destination || destination.project.id !== watch.destination.id || destination.project.root !== watch.destination.root)
+    throw new Error("The saved project is no longer locally authorized");
+  return {
+    launch: watch,
+    preparedAt: Date.now(),
+    phase: "released",
+    threadId: thread.id,
+    cwd: destination.cwd,
+    status: {
+      launchId: watch.id,
+      sequence: watch.sequence + 1,
+      state: "unreachable",
+      waiting: false,
+      turnId: null,
+      message: "Checking the linked task in Codex. Activity is observed from the next status hook."
+    }
+  };
+}
+
 // src/runtime.ts
 var sourceMarker = (id) => `kernel-handoff:${id}`;
 function initialReceipt(launch) {
@@ -22287,7 +22645,7 @@ function initialReceipt(launch) {
   };
 }
 function canBegin(receipt, now) {
-  return receipt.phase === "prepared" && now < Date.parse(receipt.launch.expiresAt);
+  return receipt.phase === "prepared" && "expiresAt" in receipt.launch && now < Date.parse(receipt.launch.expiresAt);
 }
 async function findCreation(server, receipt) {
   let cursor = null;
@@ -22316,6 +22674,8 @@ async function runCompanion(machineId, entrypoint2, signal) {
   const unlock = await processLock(directory);
   const owners = /* @__PURE__ */ new Map();
   let observer;
+  let lookupServer;
+  let lookupWork;
   try {
     const pairing = await readJson(join4(directory, "pairing.json"));
     if (!pairing?.workspaceId) throw new Error("Complete this machine pairing first");
@@ -22343,6 +22703,26 @@ async function runCompanion(machineId, entrypoint2, signal) {
       )
     );
     const queue = [];
+    const lookupService = new CodexThreadLookupService();
+    let lookupBusy = false;
+    const lookupResults = [];
+    const watched = /* @__PURE__ */ new Map();
+    const watchAttempts = /* @__PURE__ */ new Map();
+    const watchResults = [];
+    let watchCursor = null;
+    const connectLookup = async () => {
+      if (!lookupServer) {
+        lookupServer = new AppServer(directory);
+        try {
+          await lookupServer.initialize();
+        } catch (error51) {
+          lookupServer.close();
+          lookupServer = void 0;
+          throw error51;
+        }
+      }
+      return lookupServer;
+    };
     const connectObserver = async () => {
       observer?.close();
       observer = new AppServer(directory);
@@ -22353,6 +22733,9 @@ async function runCompanion(machineId, entrypoint2, signal) {
     let health = {
       reachable: false,
       hooksReady: false,
+      supportsModelSelection: true,
+      supportsThreadLinking: true,
+      models: [],
       appServerVersion: "",
       desktopVersion: "",
       issue: "Checking Codex compatibility."
@@ -22418,16 +22801,22 @@ async function runCompanion(machineId, entrypoint2, signal) {
           () => queue.push({ launchId: launch.id, event: { method: "kernel/closed" } })
         );
         await owner.initialize();
+        const selection = resolveModelSelection(launch, await discoverModels(owner));
+        if (!canBegin(receipt, Date.now() + clockOffset))
+          throw new Error("The launch expired while checking model availability");
+        receipt.model = selection.model;
+        receipt.effort = selection.reasoningEffort;
         receipt.phase = "creating";
         await save(receipt);
         const created = await owner.call("thread/start", {
           cwd: receipt.cwd,
           projectId: project.id,
-          threadSource: sourceMarker(launch.id)
+          threadSource: sourceMarker(launch.id),
+          model: selection.model,
+          config: { model_reasoning_effort: selection.reasoningEffort },
+          allowProviderModelFallback: false
         });
         receipt.threadId = created.thread.id;
-        receipt.model = created.model;
-        receipt.effort = created.reasoningEffort ?? null;
         receipt.phase = "created";
         await save(receipt);
         await indexThreads();
@@ -22442,14 +22831,14 @@ async function runCompanion(machineId, entrypoint2, signal) {
           input: [{ type: "text", text: codexLaunchPrompt(launch) }],
           collaborationMode: collaborationMode(
             launch.mode,
-            created.model,
-            created.reasoningEffort ?? null
+            selection.model,
+            selection.reasoningEffort
           )
         });
         receipt.turnId = response.turn.id;
         receipt.status.turnId = response.turn.id;
         await save(receipt);
-      } catch {
+      } catch (error51) {
         try {
           await owners.get(launch.id)?.stop();
         } catch {
@@ -22474,7 +22863,7 @@ async function runCompanion(machineId, entrypoint2, signal) {
           };
         } else {
           receipt.ambiguous = receipt.phase === "creating";
-          receipt.failure = receipt.ambiguous ? "Confirming whether Codex created the task. This launch will not be repeated." : "The task could not start. Check the locally authorized project and checkout policy.";
+          receipt.failure = receipt.ambiguous ? "Confirming whether Codex created the task. This launch will not be repeated." : error51 instanceof CodexModelSelectionError ? error51.message : "The task could not start. Check the locally authorized project and checkout policy.";
           if (!receipt.ambiguous) receipt.phase = "failed";
         }
         await save(receipt);
@@ -22518,21 +22907,26 @@ async function runCompanion(machineId, entrypoint2, signal) {
               "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,
+              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 {
+          } catch (error51) {
             observer?.close();
             observer = void 0;
             health = {
               ...health,
               reachable: false,
               hooksReady: false,
-              issue: "Codex could not be reached through its supported app-server interface."
+              models: [],
+              issue: error51 instanceof CodexModelSelectionError ? error51.message : "Codex could not be reached through its supported app-server interface."
             };
           }
           try {
@@ -22596,6 +22990,18 @@ async function runCompanion(machineId, entrypoint2, signal) {
           if (!reconciled || recovered) await indexThreads();
           reconciled = true;
         }
+        for (const receipt of watchResults.splice(0)) {
+          if (receipts.has(receipt.launch.id)) continue;
+          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)) {
           const receipt = receipts.get(launchId);
           if (!receipt || receipt.phase === "released" || receipt.phase === "failed") continue;
@@ -22710,6 +23116,49 @@ async function runCompanion(machineId, entrypoint2, signal) {
         }
         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
+            );
+            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 response = await post("launches", {});
           for (const launch of response.launches) await begin(codexLaunchSchema.parse(launch));
         }
@@ -22726,6 +23175,8 @@ async function runCompanion(machineId, entrypoint2, signal) {
   } finally {
     await Promise.allSettled([...owners.values()].map((server) => server.stop()));
     await observer?.stop().catch(() => void 0);
+    await lookupServer?.stop().catch(() => void 0);
+    await lookupWork;
     await unlock();
   }
 }
@@ -22783,10 +23234,10 @@ async function signedInProfile() {
 }
 async function loginCallback(state, timeoutMs = 3e5) {
   cliSecretSchema.parse(state);
-  let resolve2;
+  let resolve3;
   let reject;
   const result = new Promise((yes, no2) => {
-    resolve2 = yes;
+    resolve3 = yes;
     reject = no2;
   });
   void result.catch(() => void 0);
@@ -22823,11 +23274,11 @@ async function loginCallback(state, timeoutMs = 3e5) {
       `<html><title>Kernel CLI</title><body style="font:18px system-ui;padding:48px"><h1>${cancelled ? "Login cancelled" : "Return to your terminal"}</h1><p>${cancelled ? "No CLI login was granted." : "Kernel is finishing your CLI login. You can close this tab."}</p></body></html>`
     );
     if (cancelled) reject(new Error("Login cancelled. No connection was created."));
-    else resolve2(code);
+    else resolve3(code);
   });
-  await new Promise((resolve3, reject2) => {
+  await new Promise((resolve4, reject2) => {
     server.once("error", reject2);
-    server.listen(0, "127.0.0.1", resolve3);
+    server.listen(0, "127.0.0.1", resolve4);
   });
   port = server.address().port;
   const timer = setTimeout(
@@ -22837,7 +23288,7 @@ async function loginCallback(state, timeoutMs = 3e5) {
   const close = async () => {
     clearTimeout(timer);
     server.closeAllConnections();
-    await new Promise((resolve3) => server.close(() => resolve3()));
+    await new Promise((resolve4) => server.close(() => resolve4()));
   };
   return { redirectUri: `http://127.0.0.1:${port}/callback`, result, close };
 }
@@ -22918,12 +23369,12 @@ 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 { homedir as homedir4 } from "node:os";
-import { dirname as dirname2, join as join6, resolve } from "node:path";
+import { dirname as dirname2, join as join6, resolve as resolve2 } from "node:path";
 import { randomUUID as randomUUID5 } from "node:crypto";
 var installedEntrypoint = join6(dataRoot, "bin/kernel-companion.mjs");
 async function installBundle(entrypoint2) {
   await mkdir4(dirname2(installedEntrypoint), { recursive: true, mode: 448 });
-  if (resolve(entrypoint2) !== resolve(installedEntrypoint)) {
+  if (resolve2(entrypoint2) !== resolve2(installedEntrypoint)) {
     const temporary = `${installedEntrypoint}.${randomUUID5()}.tmp`;
     try {
       await copyFile(entrypoint2, temporary);
@@ -23243,7 +23694,7 @@ async function main() {
   }
   if (command === "--version") {
     process.stdout.write(
-      `${false ? "development" : "0.1.0"}
+      `${false ? "development" : "0.1.2"}
 `
     );
     return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@supercorks/krnl",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Connect Kernel to Codex on your Mac",
   "type": "module",
   "bin": {
@@ -17,4 +17,4 @@
   "publishConfig": {
     "access": "public"
   }
-}
+}