@supercorks/krnl 0.1.1 → 0.1.2

package/README.md

@@ -57,6 +57,7 @@ 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
@@ -83,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
@@ -100,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(() => {
@@ -22099,6 +22099,7 @@ var codexHealthSchema = external_exports.strictObject({
   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),
@@ -22225,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;
@@ -22363,6 +22441,192 @@ function resolveModelSelection(launch, models) {
   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) {
@@ -22381,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;
@@ -22410,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");
@@ -22437,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);
@@ -22448,6 +22734,7 @@ async function runCompanion(machineId, entrypoint2, signal) {
       reachable: false,
       hooksReady: false,
       supportsModelSelection: true,
+      supportsThreadLinking: true,
       models: [],
       appServerVersion: "",
       desktopVersion: "",
@@ -22625,6 +22912,7 @@ async function runCompanion(machineId, entrypoint2, signal) {
               reachable: true,
               hooksReady: ready,
               supportsModelSelection: true,
+              supportsThreadLinking: true,
               models,
               appServerVersion: stdout.trim(),
               desktopVersion: desktop,
@@ -22702,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;
@@ -22816,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));
         }
@@ -22832,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();
   }
 }
@@ -22889,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);
@@ -22929,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(
@@ -22943,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 };
 }
@@ -23024,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);
@@ -23349,7 +23694,7 @@ async function main() {
   }
   if (command === "--version") {
     process.stdout.write(
-      `${false ? "development" : "0.1.1"}
+      `${false ? "development" : "0.1.2"}
 `
     );
     return;

package/package.json

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