@specific.dev/cli 0.1.140 → 0.1.142

package/dist/cli.js

@@ -520,10 +520,10 @@ ${frame}`;
 });
 
 // node_modules/.pnpm/is-docker@3.0.0/node_modules/is-docker/index.js
-import fs14 from "node:fs";
+import fs15 from "node:fs";
 function hasDockerEnv() {
   try {
-    fs14.statSync("/.dockerenv");
+    fs15.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -531,7 +531,7 @@ function hasDockerEnv() {
 }
 function hasDockerCGroup() {
   try {
-    return fs14.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs15.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -549,7 +549,7 @@ var init_is_docker = __esm({
 });
 
 // node_modules/.pnpm/is-inside-container@1.0.0/node_modules/is-inside-container/index.js
-import fs15 from "node:fs";
+import fs16 from "node:fs";
 function isInsideContainer() {
   if (cachedResult === void 0) {
     cachedResult = hasContainerEnv() || isDocker();
@@ -562,7 +562,7 @@ var init_is_inside_container = __esm({
     init_is_docker();
     hasContainerEnv = () => {
       try {
-        fs15.statSync("/run/.containerenv");
+        fs16.statSync("/run/.containerenv");
         return true;
       } catch {
         return false;
@@ -574,7 +574,7 @@ var init_is_inside_container = __esm({
 // node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js
 import process2 from "node:process";
 import os3 from "node:os";
-import fs16 from "node:fs";
+import fs17 from "node:fs";
 var isWsl, is_wsl_default;
 var init_is_wsl = __esm({
   "node_modules/.pnpm/is-wsl@3.1.0/node_modules/is-wsl/index.js"() {
@@ -590,7 +590,7 @@ var init_is_wsl = __esm({
         return true;
       }
       try {
-        return fs16.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
+        return fs17.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isInsideContainer() : false;
       } catch {
         return false;
       }
@@ -660,7 +660,7 @@ var init_utilities = __esm({
 // node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/index.js
 import { promisify as promisify3 } from "node:util";
 import childProcess2 from "node:child_process";
-import fs17, { constants as fsConstants } from "node:fs/promises";
+import fs18, { constants as fsConstants } from "node:fs/promises";
 var execFile3, wslDrivesMountPoint, powerShellPathFromWsl, powerShellPath2, canAccessPowerShellPromise, canAccessPowerShell, wslDefaultBrowser, convertWslPathToWindows;
 var init_wsl_utils = __esm({
   "node_modules/.pnpm/wsl-utils@0.3.1/node_modules/wsl-utils/index.js"() {
@@ -679,14 +679,14 @@ var init_wsl_utils = __esm({
         const configFilePath = "/etc/wsl.conf";
         let isConfigFileExists = false;
         try {
-          await fs17.access(configFilePath, fsConstants.F_OK);
+          await fs18.access(configFilePath, fsConstants.F_OK);
           isConfigFileExists = true;
         } catch {
         }
         if (!isConfigFileExists) {
           return defaultMountPoint;
         }
-        const configContent = await fs17.readFile(configFilePath, { encoding: "utf8" });
+        const configContent = await fs18.readFile(configFilePath, { encoding: "utf8" });
         const parsedMountPoint = parseMountPointFromConfig(configContent);
         if (parsedMountPoint === void 0) {
           return defaultMountPoint;
@@ -705,7 +705,7 @@ var init_wsl_utils = __esm({
       canAccessPowerShellPromise ??= (async () => {
         try {
           const psPath = await powerShellPath2();
-          await fs17.access(psPath, fsConstants.X_OK);
+          await fs18.access(psPath, fsConstants.X_OK);
           return true;
         } catch {
           return false;
@@ -719,15 +719,15 @@ var init_wsl_utils = __esm({
       const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
       return stdout.trim();
     };
-    convertWslPathToWindows = async (path27) => {
-      if (/^[a-z]+:\/\//i.test(path27)) {
-        return path27;
+    convertWslPathToWindows = async (path28) => {
+      if (/^[a-z]+:\/\//i.test(path28)) {
+        return path28;
       }
       try {
-        const { stdout } = await execFile3("wslpath", ["-aw", path27], { encoding: "utf8" });
+        const { stdout } = await execFile3("wslpath", ["-aw", path28], { encoding: "utf8" });
         return stdout.trim();
       } catch {
-        return path27;
+        return path28;
       }
     };
   }
@@ -913,10 +913,10 @@ __export(open_exports, {
   openApp: () => openApp
 });
 import process8 from "node:process";
-import path16 from "node:path";
+import path17 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import childProcess3 from "node:child_process";
-import fs18, { constants as fsConstants2 } from "node:fs/promises";
+import fs19, { constants as fsConstants2 } from "node:fs/promises";
 function detectArchBinary(binary) {
   if (typeof binary === "string" || Array.isArray(binary)) {
     return binary;
@@ -946,8 +946,8 @@ var init_open = __esm({
     init_is_inside_container();
     init_is_in_ssh();
     fallbackAttemptSymbol = Symbol("fallbackAttempt");
-    __dirname2 = import.meta.url ? path16.dirname(fileURLToPath2(import.meta.url)) : "";
-    localXdgOpenPath = path16.join(__dirname2, "xdg-open");
+    __dirname2 = import.meta.url ? path17.dirname(fileURLToPath2(import.meta.url)) : "";
+    localXdgOpenPath = path17.join(__dirname2, "xdg-open");
     ({ platform: platform2, arch: arch2 } = process8);
     tryEachApp = async (apps2, opener) => {
       if (apps2.length === 0) {
@@ -1095,7 +1095,7 @@ var init_open = __esm({
           const isBundled = !__dirname2 || __dirname2 === "/";
           let exeLocalXdgOpen = false;
           try {
-            await fs18.access(localXdgOpenPath, fsConstants2.X_OK);
+            await fs19.access(localXdgOpenPath, fsConstants2.X_OK);
             exeLocalXdgOpen = true;
           } catch {
           }
@@ -1118,19 +1118,19 @@ var init_open = __esm({
       }
       const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
       if (options2.wait) {
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           subprocess.once("error", reject);
           subprocess.once("close", (exitCode) => {
             if (!options2.allowNonzeroExitCode && exitCode !== 0) {
               reject(new Error(`Exited with code ${exitCode}`));
               return;
             }
-            resolve9(subprocess);
+            resolve10(subprocess);
           });
         });
       }
       if (isFallbackAttempt) {
-        return new Promise((resolve9, reject) => {
+        return new Promise((resolve10, reject) => {
           subprocess.once("error", reject);
           subprocess.once("spawn", () => {
             subprocess.once("close", (exitCode) => {
@@ -1140,17 +1140,17 @@ var init_open = __esm({
                 return;
               }
               subprocess.unref();
-              resolve9(subprocess);
+              resolve10(subprocess);
             });
           });
         });
       }
       subprocess.unref();
-      return new Promise((resolve9, reject) => {
+      return new Promise((resolve10, reject) => {
         subprocess.once("error", reject);
         subprocess.once("spawn", () => {
           subprocess.off("error", reject);
-          resolve9(subprocess);
+          resolve10(subprocess);
         });
       });
     };
@@ -1235,8 +1235,8 @@ var require_dist2 = __commonJS({
       var $global, $module, $NaN = NaN;
       if ("undefined" != typeof window ? $global = window : "undefined" != typeof self ? $global = self : "undefined" != typeof global ? ($global = global).require = __require : $global = this, void 0 === $global || void 0 === $global.Array) throw new Error("no global object found");
       if ("undefined" != typeof module && ($module = module), !$global.fs && $global.require) try {
-        var fs29 = $global.require("fs");
-        "object" == typeof fs29 && null !== fs29 && 0 !== Object.keys(fs29).length && ($global.fs = fs29);
+        var fs30 = $global.require("fs");
+        "object" == typeof fs30 && null !== fs30 && 0 !== Object.keys(fs30).length && ($global.fs = fs30);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -183429,8 +183429,8 @@ import { Command } from "commander";
 // src/commands/init.tsx
 import React2, { useState, useEffect } from "react";
 import { render as render2, Text as Text2, Box as Box2, useInput, useApp } from "ink";
-import * as fs20 from "fs";
-import * as path18 from "path";
+import * as fs21 from "fs";
+import * as path19 from "path";
 
 // node_modules/.pnpm/@specific+sdk@file+..+sdk/node_modules/@specific/sdk/dist/index.js
 import * as fs from "fs";
@@ -183440,8 +183440,8 @@ import { execSync } from "child_process";
 import * as fs2 from "fs";
 import * as path2 from "path";
 import { createTarPacker, createEntryItemGenerator } from "tar-vern";
-import * as fs13 from "fs";
-import * as path14 from "path";
+import * as fs14 from "fs";
+import * as path15 from "path";
 
 // node_modules/.pnpm/chokidar@5.0.0/node_modules/chokidar/index.js
 import { EventEmitter } from "node:events";
@@ -183533,7 +183533,7 @@ var ReaddirpStream = class extends Readable {
     this._directoryFilter = normalizeFilter(opts.directoryFilter);
     const statMethod = opts.lstat ? lstat : stat;
     if (wantBigintFsStats) {
-      this._stat = (path27) => statMethod(path27, { bigint: true });
+      this._stat = (path28) => statMethod(path28, { bigint: true });
     } else {
       this._stat = statMethod;
     }
@@ -183558,8 +183558,8 @@ var ReaddirpStream = class extends Readable {
         const par = this.parent;
         const fil = par && par.files;
         if (fil && fil.length > 0) {
-          const { path: path27, depth } = par;
-          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path27));
+          const { path: path28, depth } = par;
+          const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path28));
           const awaited = await Promise.all(slice);
           for (const entry of awaited) {
             if (!entry)
@@ -183599,20 +183599,20 @@ var ReaddirpStream = class extends Readable {
       this.reading = false;
     }
   }
-  async _exploreDir(path27, depth) {
+  async _exploreDir(path28, depth) {
     let files;
     try {
-      files = await readdir(path27, this._rdOptions);
+      files = await readdir(path28, this._rdOptions);
     } catch (error) {
       this._onError(error);
     }
-    return { files, depth, path: path27 };
+    return { files, depth, path: path28 };
   }
-  async _formatEntry(dirent, path27) {
+  async _formatEntry(dirent, path28) {
     let entry;
     const basename6 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path27, basename6));
+      const fullPath = presolve(pjoin(path28, basename6));
       entry = { path: prelative(this._root, fullPath), fullPath, basename: basename6 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
@@ -184012,16 +184012,16 @@ var delFromSet = (main, prop, item) => {
 };
 var isEmptySet = (val) => val instanceof Set ? val.size === 0 : !val;
 var FsWatchInstances = /* @__PURE__ */ new Map();
-function createFsWatchInstance(path27, options2, listener, errHandler, emitRaw) {
+function createFsWatchInstance(path28, options2, listener, errHandler, emitRaw) {
   const handleEvent = (rawEvent, evPath) => {
-    listener(path27);
-    emitRaw(rawEvent, evPath, { watchedPath: path27 });
-    if (evPath && path27 !== evPath) {
-      fsWatchBroadcast(sp.resolve(path27, evPath), KEY_LISTENERS, sp.join(path27, evPath));
+    listener(path28);
+    emitRaw(rawEvent, evPath, { watchedPath: path28 });
+    if (evPath && path28 !== evPath) {
+      fsWatchBroadcast(sp.resolve(path28, evPath), KEY_LISTENERS, sp.join(path28, evPath));
     }
   };
   try {
-    return fs_watch(path27, {
+    return fs_watch(path28, {
       persistent: options2.persistent
     }, handleEvent);
   } catch (error) {
@@ -184037,12 +184037,12 @@ var fsWatchBroadcast = (fullPath, listenerType, val1, val2, val3) => {
     listener(val1, val2, val3);
   });
 };
-var setFsWatchListener = (path27, fullPath, options2, handlers) => {
+var setFsWatchListener = (path28, fullPath, options2, handlers) => {
   const { listener, errHandler, rawEmitter } = handlers;
   let cont = FsWatchInstances.get(fullPath);
   let watcher;
   if (!options2.persistent) {
-    watcher = createFsWatchInstance(path27, options2, listener, errHandler, rawEmitter);
+    watcher = createFsWatchInstance(path28, options2, listener, errHandler, rawEmitter);
     if (!watcher)
       return;
     return watcher.close.bind(watcher);
@@ -184053,7 +184053,7 @@ var setFsWatchListener = (path27, fullPath, options2, handlers) => {
     addAndConvert(cont, KEY_RAW, rawEmitter);
   } else {
     watcher = createFsWatchInstance(
-      path27,
+      path28,
       options2,
       fsWatchBroadcast.bind(null, fullPath, KEY_LISTENERS),
       errHandler,
@@ -184068,7 +184068,7 @@ var setFsWatchListener = (path27, fullPath, options2, handlers) => {
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open(path27, "r");
+          const fd = await open(path28, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {
@@ -184099,7 +184099,7 @@ var setFsWatchListener = (path27, fullPath, options2, handlers) => {
   };
 };
 var FsWatchFileInstances = /* @__PURE__ */ new Map();
-var setFsWatchFileListener = (path27, fullPath, options2, handlers) => {
+var setFsWatchFileListener = (path28, fullPath, options2, handlers) => {
   const { listener, rawEmitter } = handlers;
   let cont = FsWatchFileInstances.get(fullPath);
   const copts = cont && cont.options;
@@ -184121,7 +184121,7 @@ var setFsWatchFileListener = (path27, fullPath, options2, handlers) => {
         });
         const currmtime = curr.mtimeMs;
         if (curr.size !== prev.size || currmtime > prev.mtimeMs || currmtime === 0) {
-          foreach(cont.listeners, (listener2) => listener2(path27, curr));
+          foreach(cont.listeners, (listener2) => listener2(path28, curr));
         }
       })
     };
@@ -184151,13 +184151,13 @@ var NodeFsHandler = class {
    * @param listener on fs change
    * @returns closer for the watcher instance
    */
-  _watchWithNodeFs(path27, listener) {
+  _watchWithNodeFs(path28, listener) {
     const opts = this.fsw.options;
-    const directory = sp.dirname(path27);
-    const basename6 = sp.basename(path27);
+    const directory = sp.dirname(path28);
+    const basename6 = sp.basename(path28);
     const parent = this.fsw._getWatchedDir(directory);
     parent.add(basename6);
-    const absolutePath = sp.resolve(path27);
+    const absolutePath = sp.resolve(path28);
     const options2 = {
       persistent: opts.persistent
     };
@@ -184167,12 +184167,12 @@ var NodeFsHandler = class {
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
       options2.interval = enableBin && isBinaryPath(basename6) ? opts.binaryInterval : opts.interval;
-      closer = setFsWatchFileListener(path27, absolutePath, options2, {
+      closer = setFsWatchFileListener(path28, absolutePath, options2, {
         listener,
         rawEmitter: this.fsw._emitRaw
       });
     } else {
-      closer = setFsWatchListener(path27, absolutePath, options2, {
+      closer = setFsWatchListener(path28, absolutePath, options2, {
         listener,
         errHandler: this._boundHandleError,
         rawEmitter: this.fsw._emitRaw
@@ -184194,7 +184194,7 @@ var NodeFsHandler = class {
     let prevStats = stats;
     if (parent.has(basename6))
       return;
-    const listener = async (path27, newStats) => {
+    const listener = async (path28, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file, 5))
         return;
       if (!newStats || newStats.mtimeMs === 0) {
@@ -184208,11 +184208,11 @@ var NodeFsHandler = class {
             this.fsw._emit(EV.CHANGE, file, newStats2);
           }
           if ((isMacos || isLinux || isFreeBSD) && prevStats.ino !== newStats2.ino) {
-            this.fsw._closeFile(path27);
+            this.fsw._closeFile(path28);
             prevStats = newStats2;
             const closer2 = this._watchWithNodeFs(file, listener);
             if (closer2)
-              this.fsw._addPathCloser(path27, closer2);
+              this.fsw._addPathCloser(path28, closer2);
           } else {
             prevStats = newStats2;
           }
@@ -184244,7 +184244,7 @@ var NodeFsHandler = class {
    * @param item basename of this item
    * @returns true if no more processing is needed for this entry.
    */
-  async _handleSymlink(entry, directory, path27, item) {
+  async _handleSymlink(entry, directory, path28, item) {
     if (this.fsw.closed) {
       return;
     }
@@ -184254,7 +184254,7 @@ var NodeFsHandler = class {
       this.fsw._incrReadyCount();
       let linkPath;
       try {
-        linkPath = await fsrealpath(path27);
+        linkPath = await fsrealpath(path28);
       } catch (e) {
         this.fsw._emitReady();
         return true;
@@ -184264,12 +184264,12 @@ var NodeFsHandler = class {
       if (dir.has(item)) {
         if (this.fsw._symlinkPaths.get(full) !== linkPath) {
           this.fsw._symlinkPaths.set(full, linkPath);
-          this.fsw._emit(EV.CHANGE, path27, entry.stats);
+          this.fsw._emit(EV.CHANGE, path28, entry.stats);
         }
       } else {
         dir.add(item);
         this.fsw._symlinkPaths.set(full, linkPath);
-        this.fsw._emit(EV.ADD, path27, entry.stats);
+        this.fsw._emit(EV.ADD, path28, entry.stats);
       }
       this.fsw._emitReady();
       return true;
@@ -184299,9 +184299,9 @@ var NodeFsHandler = class {
         return;
       }
       const item = entry.path;
-      let path27 = sp.join(directory, item);
+      let path28 = sp.join(directory, item);
       current.add(item);
-      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path27, item)) {
+      if (entry.stats.isSymbolicLink() && await this._handleSymlink(entry, directory, path28, item)) {
         return;
       }
       if (this.fsw.closed) {
@@ -184310,11 +184310,11 @@ var NodeFsHandler = class {
       }
       if (item === target || !target && !previous.has(item)) {
         this.fsw._incrReadyCount();
-        path27 = sp.join(dir, sp.relative(dir, path27));
-        this._addToNodeFs(path27, initialAdd, wh, depth + 1);
+        path28 = sp.join(dir, sp.relative(dir, path28));
+        this._addToNodeFs(path28, initialAdd, wh, depth + 1);
       }
     }).on(EV.ERROR, this._boundHandleError);
-    return new Promise((resolve9, reject) => {
+    return new Promise((resolve10, reject) => {
       if (!stream)
         return reject();
       stream.once(STR_END, () => {
@@ -184323,7 +184323,7 @@ var NodeFsHandler = class {
           return;
         }
         const wasThrottled = throttler ? throttler.clear() : false;
-        resolve9(void 0);
+        resolve10(void 0);
         previous.getChildren().filter((item) => {
           return item !== directory && !current.has(item);
         }).forEach((item) => {
@@ -184380,13 +184380,13 @@ var NodeFsHandler = class {
    * @param depth Child path actually targeted for watch
    * @param target Child path actually targeted for watch
    */
-  async _addToNodeFs(path27, initialAdd, priorWh, depth, target) {
+  async _addToNodeFs(path28, initialAdd, priorWh, depth, target) {
     const ready = this.fsw._emitReady;
-    if (this.fsw._isIgnored(path27) || this.fsw.closed) {
+    if (this.fsw._isIgnored(path28) || this.fsw.closed) {
       ready();
       return false;
     }
-    const wh = this.fsw._getWatchHelpers(path27);
+    const wh = this.fsw._getWatchHelpers(path28);
     if (priorWh) {
       wh.filterPath = (entry) => priorWh.filterPath(entry);
       wh.filterDir = (entry) => priorWh.filterDir(entry);
@@ -184402,8 +184402,8 @@ var NodeFsHandler = class {
       const follow = this.fsw.options.followSymlinks;
       let closer;
       if (stats.isDirectory()) {
-        const absPath = sp.resolve(path27);
-        const targetPath = follow ? await fsrealpath(path27) : path27;
+        const absPath = sp.resolve(path28);
+        const targetPath = follow ? await fsrealpath(path28) : path28;
         if (this.fsw.closed)
           return;
         closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -184413,29 +184413,29 @@ var NodeFsHandler = class {
           this.fsw._symlinkPaths.set(absPath, targetPath);
         }
       } else if (stats.isSymbolicLink()) {
-        const targetPath = follow ? await fsrealpath(path27) : path27;
+        const targetPath = follow ? await fsrealpath(path28) : path28;
         if (this.fsw.closed)
           return;
         const parent = sp.dirname(wh.watchPath);
         this.fsw._getWatchedDir(parent).add(wh.watchPath);
         this.fsw._emit(EV.ADD, wh.watchPath, stats);
-        closer = await this._handleDir(parent, stats, initialAdd, depth, path27, wh, targetPath);
+        closer = await this._handleDir(parent, stats, initialAdd, depth, path28, wh, targetPath);
         if (this.fsw.closed)
           return;
         if (targetPath !== void 0) {
-          this.fsw._symlinkPaths.set(sp.resolve(path27), targetPath);
+          this.fsw._symlinkPaths.set(sp.resolve(path28), targetPath);
         }
       } else {
         closer = this._handleFile(wh.watchPath, stats, initialAdd);
       }
       ready();
       if (closer)
-        this.fsw._addPathCloser(path27, closer);
+        this.fsw._addPathCloser(path28, closer);
       return false;
     } catch (error) {
       if (this.fsw._handleError(error)) {
         ready();
-        return path27;
+        return path28;
       }
     }
   }
@@ -184478,24 +184478,24 @@ function createPattern(matcher) {
   }
   return () => false;
 }
-function normalizePath(path27) {
-  if (typeof path27 !== "string")
+function normalizePath(path28) {
+  if (typeof path28 !== "string")
     throw new Error("string expected");
-  path27 = sp2.normalize(path27);
-  path27 = path27.replace(/\\/g, "/");
+  path28 = sp2.normalize(path28);
+  path28 = path28.replace(/\\/g, "/");
   let prepend = false;
-  if (path27.startsWith("//"))
+  if (path28.startsWith("//"))
     prepend = true;
-  path27 = path27.replace(DOUBLE_SLASH_RE, "/");
+  path28 = path28.replace(DOUBLE_SLASH_RE, "/");
   if (prepend)
-    path27 = "/" + path27;
-  return path27;
+    path28 = "/" + path28;
+  return path28;
 }
 function matchPatterns(patterns, testString, stats) {
-  const path27 = normalizePath(testString);
+  const path28 = normalizePath(testString);
   for (let index = 0; index < patterns.length; index++) {
     const pattern = patterns[index];
-    if (pattern(path27, stats)) {
+    if (pattern(path28, stats)) {
       return true;
     }
   }
@@ -184533,19 +184533,19 @@ var toUnix = (string) => {
   }
   return str;
 };
-var normalizePathToUnix = (path27) => toUnix(sp2.normalize(toUnix(path27)));
-var normalizeIgnored = (cwd = "") => (path27) => {
-  if (typeof path27 === "string") {
-    return normalizePathToUnix(sp2.isAbsolute(path27) ? path27 : sp2.join(cwd, path27));
+var normalizePathToUnix = (path28) => toUnix(sp2.normalize(toUnix(path28)));
+var normalizeIgnored = (cwd = "") => (path28) => {
+  if (typeof path28 === "string") {
+    return normalizePathToUnix(sp2.isAbsolute(path28) ? path28 : sp2.join(cwd, path28));
   } else {
-    return path27;
+    return path28;
   }
 };
-var getAbsolutePath = (path27, cwd) => {
-  if (sp2.isAbsolute(path27)) {
-    return path27;
+var getAbsolutePath = (path28, cwd) => {
+  if (sp2.isAbsolute(path28)) {
+    return path28;
   }
-  return sp2.join(cwd, path27);
+  return sp2.join(cwd, path28);
 };
 var EMPTY_SET = Object.freeze(/* @__PURE__ */ new Set());
 var DirEntry = class {
@@ -184610,10 +184610,10 @@ var WatchHelper = class {
   dirParts;
   followSymlinks;
   statMethod;
-  constructor(path27, follow, fsw) {
+  constructor(path28, follow, fsw) {
     this.fsw = fsw;
-    const watchPath = path27;
-    this.path = path27 = path27.replace(REPLACER_RE, "");
+    const watchPath = path28;
+    this.path = path28 = path28.replace(REPLACER_RE, "");
     this.watchPath = watchPath;
     this.fullWatchPath = sp2.resolve(watchPath);
     this.dirParts = [];
@@ -184753,20 +184753,20 @@ var FSWatcher = class extends EventEmitter {
     this._closePromise = void 0;
     let paths = unifyPaths(paths_);
     if (cwd) {
-      paths = paths.map((path27) => {
-        const absPath = getAbsolutePath(path27, cwd);
+      paths = paths.map((path28) => {
+        const absPath = getAbsolutePath(path28, cwd);
         return absPath;
       });
     }
-    paths.forEach((path27) => {
-      this._removeIgnoredPath(path27);
+    paths.forEach((path28) => {
+      this._removeIgnoredPath(path28);
     });
     this._userIgnored = void 0;
     if (!this._readyCount)
       this._readyCount = 0;
     this._readyCount += paths.length;
-    Promise.all(paths.map(async (path27) => {
-      const res = await this._nodeFsHandler._addToNodeFs(path27, !_internal, void 0, 0, _origAdd);
+    Promise.all(paths.map(async (path28) => {
+      const res = await this._nodeFsHandler._addToNodeFs(path28, !_internal, void 0, 0, _origAdd);
       if (res)
         this._emitReady();
       return res;
@@ -184788,17 +184788,17 @@ var FSWatcher = class extends EventEmitter {
       return this;
     const paths = unifyPaths(paths_);
     const { cwd } = this.options;
-    paths.forEach((path27) => {
-      if (!sp2.isAbsolute(path27) && !this._closers.has(path27)) {
+    paths.forEach((path28) => {
+      if (!sp2.isAbsolute(path28) && !this._closers.has(path28)) {
         if (cwd)
-          path27 = sp2.join(cwd, path27);
-        path27 = sp2.resolve(path27);
+          path28 = sp2.join(cwd, path28);
+        path28 = sp2.resolve(path28);
       }
-      this._closePath(path27);
-      this._addIgnoredPath(path27);
-      if (this._watched.has(path27)) {
+      this._closePath(path28);
+      this._addIgnoredPath(path28);
+      if (this._watched.has(path28)) {
         this._addIgnoredPath({
-          path: path27,
+          path: path28,
           recursive: true
         });
       }
@@ -184862,38 +184862,38 @@ var FSWatcher = class extends EventEmitter {
    * @param stats arguments to be passed with event
    * @returns the error if defined, otherwise the value of the FSWatcher instance's `closed` flag
    */
-  async _emit(event, path27, stats) {
+  async _emit(event, path28, stats) {
     if (this.closed)
       return;
     const opts = this.options;
     if (isWindows)
-      path27 = sp2.normalize(path27);
+      path28 = sp2.normalize(path28);
     if (opts.cwd)
-      path27 = sp2.relative(opts.cwd, path27);
-    const args = [path27];
+      path28 = sp2.relative(opts.cwd, path28);
+    const args = [path28];
     if (stats != null)
       args.push(stats);
     const awf = opts.awaitWriteFinish;
     let pw;
-    if (awf && (pw = this._pendingWrites.get(path27))) {
+    if (awf && (pw = this._pendingWrites.get(path28))) {
       pw.lastChange = /* @__PURE__ */ new Date();
       return this;
     }
     if (opts.atomic) {
       if (event === EVENTS.UNLINK) {
-        this._pendingUnlinks.set(path27, [event, ...args]);
+        this._pendingUnlinks.set(path28, [event, ...args]);
         setTimeout(() => {
-          this._pendingUnlinks.forEach((entry, path28) => {
+          this._pendingUnlinks.forEach((entry, path29) => {
             this.emit(...entry);
             this.emit(EVENTS.ALL, ...entry);
-            this._pendingUnlinks.delete(path28);
+            this._pendingUnlinks.delete(path29);
           });
         }, typeof opts.atomic === "number" ? opts.atomic : 100);
         return this;
       }
-      if (event === EVENTS.ADD && this._pendingUnlinks.has(path27)) {
+      if (event === EVENTS.ADD && this._pendingUnlinks.has(path28)) {
         event = EVENTS.CHANGE;
-        this._pendingUnlinks.delete(path27);
+        this._pendingUnlinks.delete(path28);
       }
     }
     if (awf && (event === EVENTS.ADD || event === EVENTS.CHANGE) && this._readyEmitted) {
@@ -184911,16 +184911,16 @@ var FSWatcher = class extends EventEmitter {
           this.emitWithAll(event, args);
         }
       };
-      this._awaitWriteFinish(path27, awf.stabilityThreshold, event, awfEmit);
+      this._awaitWriteFinish(path28, awf.stabilityThreshold, event, awfEmit);
       return this;
     }
     if (event === EVENTS.CHANGE) {
-      const isThrottled = !this._throttle(EVENTS.CHANGE, path27, 50);
+      const isThrottled = !this._throttle(EVENTS.CHANGE, path28, 50);
       if (isThrottled)
         return this;
     }
     if (opts.alwaysStat && stats === void 0 && (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-      const fullPath = opts.cwd ? sp2.join(opts.cwd, path27) : path27;
+      const fullPath = opts.cwd ? sp2.join(opts.cwd, path28) : path28;
       let stats2;
       try {
         stats2 = await stat3(fullPath);
@@ -184951,23 +184951,23 @@ var FSWatcher = class extends EventEmitter {
    * @param timeout duration of time to suppress duplicate actions
    * @returns tracking object or false if action should be suppressed
    */
-  _throttle(actionType, path27, timeout) {
+  _throttle(actionType, path28, timeout) {
     if (!this._throttled.has(actionType)) {
       this._throttled.set(actionType, /* @__PURE__ */ new Map());
     }
     const action = this._throttled.get(actionType);
     if (!action)
       throw new Error("invalid throttle");
-    const actionPath = action.get(path27);
+    const actionPath = action.get(path28);
     if (actionPath) {
       actionPath.count++;
       return false;
     }
     let timeoutObject;
     const clear = () => {
-      const item = action.get(path27);
+      const item = action.get(path28);
       const count = item ? item.count : 0;
-      action.delete(path27);
+      action.delete(path28);
       clearTimeout(timeoutObject);
       if (item)
         clearTimeout(item.timeoutObject);
@@ -184975,7 +184975,7 @@ var FSWatcher = class extends EventEmitter {
     };
     timeoutObject = setTimeout(clear, timeout);
     const thr = { timeoutObject, clear, count: 0 };
-    action.set(path27, thr);
+    action.set(path28, thr);
     return thr;
   }
   _incrReadyCount() {
@@ -184989,44 +184989,44 @@ var FSWatcher = class extends EventEmitter {
    * @param event
    * @param awfEmit Callback to be called when ready for event to be emitted.
    */
-  _awaitWriteFinish(path27, threshold, event, awfEmit) {
+  _awaitWriteFinish(path28, threshold, event, awfEmit) {
     const awf = this.options.awaitWriteFinish;
     if (typeof awf !== "object")
       return;
     const pollInterval = awf.pollInterval;
     let timeoutHandler;
-    let fullPath = path27;
-    if (this.options.cwd && !sp2.isAbsolute(path27)) {
-      fullPath = sp2.join(this.options.cwd, path27);
+    let fullPath = path28;
+    if (this.options.cwd && !sp2.isAbsolute(path28)) {
+      fullPath = sp2.join(this.options.cwd, path28);
     }
     const now = /* @__PURE__ */ new Date();
     const writes = this._pendingWrites;
     function awaitWriteFinishFn(prevStat) {
       statcb(fullPath, (err, curStat) => {
-        if (err || !writes.has(path27)) {
+        if (err || !writes.has(path28)) {
           if (err && err.code !== "ENOENT")
             awfEmit(err);
           return;
         }
         const now2 = Number(/* @__PURE__ */ new Date());
         if (prevStat && curStat.size !== prevStat.size) {
-          writes.get(path27).lastChange = now2;
+          writes.get(path28).lastChange = now2;
         }
-        const pw = writes.get(path27);
+        const pw = writes.get(path28);
         const df = now2 - pw.lastChange;
         if (df >= threshold) {
-          writes.delete(path27);
+          writes.delete(path28);
           awfEmit(void 0, curStat);
         } else {
           timeoutHandler = setTimeout(awaitWriteFinishFn, pollInterval, curStat);
         }
       });
     }
-    if (!writes.has(path27)) {
-      writes.set(path27, {
+    if (!writes.has(path28)) {
+      writes.set(path28, {
         lastChange: now,
         cancelWait: () => {
-          writes.delete(path27);
+          writes.delete(path28);
           clearTimeout(timeoutHandler);
           return event;
         }
@@ -185037,8 +185037,8 @@ var FSWatcher = class extends EventEmitter {
   /**
    * Determines whether user has asked to ignore this path.
    */
-  _isIgnored(path27, stats) {
-    if (this.options.atomic && DOT_RE.test(path27))
+  _isIgnored(path28, stats) {
+    if (this.options.atomic && DOT_RE.test(path28))
       return true;
     if (!this._userIgnored) {
       const { cwd } = this.options;
@@ -185048,17 +185048,17 @@ var FSWatcher = class extends EventEmitter {
       const list = [...ignoredPaths.map(normalizeIgnored(cwd)), ...ignored];
       this._userIgnored = anymatch(list, void 0);
     }
-    return this._userIgnored(path27, stats);
+    return this._userIgnored(path28, stats);
   }
-  _isntIgnored(path27, stat4) {
-    return !this._isIgnored(path27, stat4);
+  _isntIgnored(path28, stat4) {
+    return !this._isIgnored(path28, stat4);
   }
   /**
    * Provides a set of common helpers and properties relating to symlink handling.
    * @param path file or directory pattern being watched
    */
-  _getWatchHelpers(path27) {
-    return new WatchHelper(path27, this.options.followSymlinks, this);
+  _getWatchHelpers(path28) {
+    return new WatchHelper(path28, this.options.followSymlinks, this);
   }
   // Directory helpers
   // -----------------
@@ -185090,63 +185090,63 @@ var FSWatcher = class extends EventEmitter {
    * @param item      base path of item/directory
    */
   _remove(directory, item, isDirectory) {
-    const path27 = sp2.join(directory, item);
-    const fullPath = sp2.resolve(path27);
-    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path27) || this._watched.has(fullPath);
-    if (!this._throttle("remove", path27, 100))
+    const path28 = sp2.join(directory, item);
+    const fullPath = sp2.resolve(path28);
+    isDirectory = isDirectory != null ? isDirectory : this._watched.has(path28) || this._watched.has(fullPath);
+    if (!this._throttle("remove", path28, 100))
       return;
     if (!isDirectory && this._watched.size === 1) {
       this.add(directory, item, true);
     }
-    const wp = this._getWatchedDir(path27);
+    const wp = this._getWatchedDir(path28);
     const nestedDirectoryChildren = wp.getChildren();
-    nestedDirectoryChildren.forEach((nested) => this._remove(path27, nested));
+    nestedDirectoryChildren.forEach((nested) => this._remove(path28, nested));
     const parent = this._getWatchedDir(directory);
     const wasTracked = parent.has(item);
     parent.remove(item);
     if (this._symlinkPaths.has(fullPath)) {
       this._symlinkPaths.delete(fullPath);
     }
-    let relPath = path27;
+    let relPath = path28;
     if (this.options.cwd)
-      relPath = sp2.relative(this.options.cwd, path27);
+      relPath = sp2.relative(this.options.cwd, path28);
     if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
       const event = this._pendingWrites.get(relPath).cancelWait();
       if (event === EVENTS.ADD)
         return;
     }
-    this._watched.delete(path27);
+    this._watched.delete(path28);
     this._watched.delete(fullPath);
     const eventName = isDirectory ? EVENTS.UNLINK_DIR : EVENTS.UNLINK;
-    if (wasTracked && !this._isIgnored(path27))
-      this._emit(eventName, path27);
-    this._closePath(path27);
+    if (wasTracked && !this._isIgnored(path28))
+      this._emit(eventName, path28);
+    this._closePath(path28);
   }
   /**
    * Closes all watchers for a path
    */
-  _closePath(path27) {
-    this._closeFile(path27);
-    const dir = sp2.dirname(path27);
-    this._getWatchedDir(dir).remove(sp2.basename(path27));
+  _closePath(path28) {
+    this._closeFile(path28);
+    const dir = sp2.dirname(path28);
+    this._getWatchedDir(dir).remove(sp2.basename(path28));
   }
   /**
    * Closes only file-specific watchers
    */
-  _closeFile(path27) {
-    const closers = this._closers.get(path27);
+  _closeFile(path28) {
+    const closers = this._closers.get(path28);
     if (!closers)
       return;
     closers.forEach((closer) => closer());
-    this._closers.delete(path27);
+    this._closers.delete(path28);
   }
-  _addPathCloser(path27, closer) {
+  _addPathCloser(path28, closer) {
     if (!closer)
       return;
-    let list = this._closers.get(path27);
+    let list = this._closers.get(path28);
     if (!list) {
       list = [];
-      this._closers.set(path27, list);
+      this._closers.set(path28, list);
     }
     list.push(closer);
   }
@@ -185221,15 +185221,17 @@ import * as fs11 from "fs";
 import * as path12 from "path";
 import * as net5 from "net";
 import { spawn as spawn5 } from "child_process";
-import * as net6 from "net";
 import * as fs12 from "fs";
 import * as path13 from "path";
+import * as net6 from "net";
+import * as fs13 from "fs";
+import * as path14 from "path";
 import { generateSlug } from "random-word-slugs";
 import { EventEmitter as EventEmitter2 } from "node:events";
 import * as net7 from "node:net";
 import { EventEmitter as EventEmitter22 } from "events";
 import { execSync as execSync2 } from "child_process";
-import * as path15 from "path";
+import * as path16 from "path";
 var __create2 = Object.create;
 var __defProp2 = Object.defineProperty;
 var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -185270,8 +185272,8 @@ var require_dist = __commonJS2({
       var $global, $module, $NaN = NaN;
       if ("undefined" != typeof window ? $global = window : "undefined" != typeof self ? $global = self : "undefined" != typeof global ? ($global = global).require = __require2 : $global = this, void 0 === $global || void 0 === $global.Array) throw new Error("no global object found");
       if ("undefined" != typeof module && ($module = module), !$global.fs && $global.require) try {
-        var fs142 = $global.require("fs");
-        "object" == typeof fs142 && null !== fs142 && 0 !== Object.keys(fs142).length && ($global.fs = fs142);
+        var fs152 = $global.require("fs");
+        "object" == typeof fs152 && null !== fs152 && 0 !== Object.keys(fs152).length && ($global.fs = fs152);
       } catch (e) {
       }
       if (!$global.fs) {
@@ -368995,10 +368997,10 @@ async function downloadFile(url, destPath, onProgress) {
         });
       }
     }
-    await new Promise((resolve52, reject) => {
+    await new Promise((resolve62, reject) => {
       fileStream.end((err) => {
         if (err) reject(err);
-        else resolve52();
+        else resolve62();
       });
     });
     fs4.renameSync(partPath, destPath);
@@ -369207,12 +369209,12 @@ var temporalBinary = {
   executables: ["temporal"]
 };
 function killProcess(proc, opts = {}) {
-  return new Promise((resolve52) => {
+  return new Promise((resolve62) => {
     if (proc.killed || proc.exitCode !== null) {
-      resolve52();
+      resolve62();
       return;
     }
-    proc.once("exit", () => resolve52());
+    proc.once("exit", () => resolve62());
     if (opts.detached && proc.pid) {
       try {
         process.kill(-proc.pid, "SIGKILL");
@@ -369232,20 +369234,20 @@ function killProcessGroup(pid) {
 }
 var execFileAsync = promisify(execFile);
 function isPortInUse(host, port) {
-  return new Promise((resolve52) => {
+  return new Promise((resolve62) => {
     const socket = new net.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve52(true);
+      resolve62(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.connect(port, host);
   });
@@ -369523,7 +369525,7 @@ async function startStorage(storage, port, dataDir) {
   };
 }
 async function runCommand(command, args, env2) {
-  return new Promise((resolve52, reject) => {
+  return new Promise((resolve62, reject) => {
     const proc = spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: env2
@@ -369534,7 +369536,7 @@ async function runCommand(command, args, env2) {
     });
     proc.on("close", (code) => {
       if (code === 0) {
-        resolve52();
+        resolve62();
       } else {
         reject(new Error(`Command failed with code ${code}: ${stderr}`));
       }
@@ -369543,7 +369545,7 @@ async function runCommand(command, args, env2) {
   });
 }
 async function createPostgresDatabase(postgresPath, dataDir, dbName, env2) {
-  return new Promise((resolve52, reject) => {
+  return new Promise((resolve62, reject) => {
     const proc = spawn(
       postgresPath,
       ["--single", "-D", dataDir, "postgres"],
@@ -369557,7 +369559,7 @@ async function createPostgresDatabase(postgresPath, dataDir, dbName, env2) {
       stderr += data.toString();
     });
     proc.on("close", (code) => {
-      resolve52();
+      resolve62();
     });
     proc.on("error", reject);
     proc.stdin?.write(`CREATE DATABASE "${dbName}";
@@ -369610,26 +369612,26 @@ async function waitForTcpPort(host, port, timeoutMs = 3e4) {
   throw new Error(`Port ${port} did not become available within timeout`);
 }
 function checkTcpPort(host, port) {
-  return new Promise((resolve52) => {
+  return new Promise((resolve62) => {
     const socket = new net2.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve52(true);
+      resolve62(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.connect(port, host);
   });
 }
 function sleep(ms) {
-  return new Promise((resolve52) => setTimeout(resolve52, ms));
+  return new Promise((resolve62) => setTimeout(resolve62, ms));
 }
 var import_hcl2_json_parser2 = __toESM2(require_dist(), 1);
 var { parseToObject: parseToObject2 } = import_hcl2_json_parser2.default;
@@ -370126,12 +370128,12 @@ function startService(service, resources, secrets, configs, endpointPorts, servi
     ports: endpointPorts,
     process: child,
     async stop() {
-      return new Promise((resolve52) => {
+      return new Promise((resolve62) => {
         if (child.killed || child.exitCode !== null) {
-          resolve52();
+          resolve62();
           return;
         }
-        child.once("exit", () => resolve52());
+        child.once("exit", () => resolve62());
         const pid = child.pid;
         if (pid) {
           killProcessGroup(pid);
@@ -370207,7 +370209,7 @@ var InstanceStateManager = class {
             }
             continue;
           }
-          await new Promise((resolve52) => setTimeout(resolve52, 100));
+          await new Promise((resolve62) => setTimeout(resolve62, 100));
         } else {
           throw e;
         }
@@ -370449,6 +370451,23 @@ function killTrackedProcess(pid, detached, isProcessRunning) {
 var __dirname = path7.dirname(fileURLToPath(import.meta.url));
 var adminDir = path7.join(__dirname, "admin");
 var _embeddedAdmin = null;
+var LOG_LINE_REGEX = /^\[([^\]]+)\] \[([^\]]+)\] (.*)$/;
+function parseLogLines(buf) {
+  const text = buf.toString("utf8");
+  if (text.length === 0) return [];
+  const trimmed = text.endsWith("\n") ? text.slice(0, -1) : text;
+  if (trimmed.length === 0) return [];
+  return trimmed.split("\n").map((line) => {
+    const m = LOG_LINE_REGEX.exec(line);
+    if (m) {
+      return { timestamp: m[1], stream: m[2], text: m[3] };
+    }
+    return { timestamp: "", stream: "raw", text: line };
+  });
+}
+function isSafeServiceName(name) {
+  return name.length > 0 && !name.includes("/") && !name.includes("\\") && !name.includes("..") && !name.includes("\0");
+}
 var MIME_TYPES = {
   ".html": "text/html",
   ".css": "text/css",
@@ -370590,8 +370609,8 @@ function proxyRequest(req, res, targetPort) {
   });
   req.pipe(proxyReq, { end: true });
 }
-async function startAdminServer(getState, listenPort = 0) {
-  return new Promise((resolve52, reject) => {
+async function startAdminServer(getState, listenPort = 0, getLogsDir = () => null) {
+  return new Promise((resolve62, reject) => {
     const server = http.createServer((req, res) => {
       const url = new URL(req.url || "/", "http://localhost");
       res.setHeader("Access-Control-Allow-Origin", "*");
@@ -370610,6 +370629,65 @@ async function startAdminServer(getState, listenPort = 0) {
         res.end(JSON.stringify(state));
         return;
       }
+      const logsMatch = /^\/api\/services\/([^/]+)\/logs$/.exec(pathname);
+      if (logsMatch) {
+        const serviceName = decodeURIComponent(logsMatch[1]);
+        if (!isSafeServiceName(serviceName)) {
+          res.writeHead(400, { "Content-Type": "text/plain" });
+          res.end("Invalid service name");
+          return;
+        }
+        const logsDir = getLogsDir();
+        if (!logsDir) {
+          res.writeHead(404, { "Content-Type": "text/plain" });
+          res.end("Logs not available");
+          return;
+        }
+        const filePath = path7.join(logsDir, `${serviceName}.log`);
+        let stat4;
+        try {
+          stat4 = fs7.statSync(filePath);
+        } catch {
+          res.writeHead(404, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ size: 0, rotated: false, lines: [] }));
+          return;
+        }
+        const offsetParam = url.searchParams.get("offset");
+        const requestedOffset = offsetParam ? parseInt(offsetParam, 10) : 0;
+        const offset = Number.isFinite(requestedOffset) && requestedOffset >= 0 ? requestedOffset : 0;
+        const rotated = offset > stat4.size;
+        const start = rotated ? 0 : offset;
+        let buf;
+        try {
+          const fd = fs7.openSync(filePath, "r");
+          try {
+            const length = Math.max(0, stat4.size - start);
+            buf = Buffer.alloc(length);
+            if (length > 0) {
+              fs7.readSync(fd, buf, 0, length, start);
+            }
+          } finally {
+            fs7.closeSync(fd);
+          }
+        } catch (err) {
+          writeLog("admin:logs", `Failed to read ${filePath}: ${err}`);
+          res.writeHead(500, { "Content-Type": "text/plain" });
+          res.end("Failed to read logs");
+          return;
+        }
+        const lastNl = buf.lastIndexOf(10);
+        const complete = lastNl >= 0 ? buf.subarray(0, lastNl + 1) : Buffer.alloc(0);
+        const newOffset = start + complete.length;
+        const body = {
+          size: newOffset,
+          rotated,
+          lines: parseLogLines(complete)
+        };
+        res.setHeader("Content-Type", "application/json");
+        res.writeHead(200);
+        res.end(JSON.stringify(body));
+        return;
+      }
       if (pathname.startsWith("/temporal-ui")) {
         const state = getState();
         if (state.temporalUiPort) {
@@ -370631,7 +370709,7 @@ async function startAdminServer(getState, listenPort = 0) {
       }
       const port = addr.port;
       writeLog("admin", `Admin server started on port ${port}`);
-      resolve52({
+      resolve62({
         port,
         stop: () => new Promise((res, rej) => {
           server.close((err) => err ? rej(err) : res());
@@ -370799,26 +370877,26 @@ async function waitForTcpPort2(host, port, timeoutMs = 3e4) {
   throw new Error(`Electric port ${port} did not become available within timeout`);
 }
 function checkTcpPort2(host, port) {
-  return new Promise((resolve52) => {
+  return new Promise((resolve62) => {
     const socket = new net3.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve52(true);
+      resolve62(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.connect(port, host);
   });
 }
 function sleep2(ms) {
-  return new Promise((resolve52) => setTimeout(resolve52, ms));
+  return new Promise((resolve62) => setTimeout(resolve62, ms));
 }
 async function startMailServer(mail, smtpPort, apiPort) {
   const emails = [];
@@ -370909,19 +370987,19 @@ async function startMailServer(mail, smtpPort, apiPort) {
     res.writeHead(404);
     res.end();
   });
-  await new Promise((resolve52, reject) => {
-    smtpServer.listen(smtpPort, "127.0.0.1", () => resolve52());
+  await new Promise((resolve62, reject) => {
+    smtpServer.listen(smtpPort, "127.0.0.1", () => resolve62());
     smtpServer.on("error", reject);
   });
-  await new Promise((resolve52, reject) => {
-    httpServer.listen(apiPort, "127.0.0.1", () => resolve52());
+  await new Promise((resolve62, reject) => {
+    httpServer.listen(apiPort, "127.0.0.1", () => resolve62());
     httpServer.on("error", reject);
   });
   const stop = async () => {
     httpServer.closeAllConnections();
     await Promise.all([
-      new Promise((resolve52) => smtpServer.close(() => resolve52())),
-      new Promise((resolve52) => httpServer.close(() => resolve52()))
+      new Promise((resolve62) => smtpServer.close(() => resolve62())),
+      new Promise((resolve62) => httpServer.close(() => resolve62()))
     ]);
   };
   const resource = {
@@ -371026,26 +371104,26 @@ async function waitForTcpPort3(host, port, timeoutMs = 3e4) {
   );
 }
 function checkTcpPort3(host, port) {
-  return new Promise((resolve52) => {
+  return new Promise((resolve62) => {
     const socket = new net4.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve52(true);
+      resolve62(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.connect(port, host);
   });
 }
 function sleep3(ms) {
-  return new Promise((resolve52) => setTimeout(resolve52, ms));
+  return new Promise((resolve62) => setTimeout(resolve62, ms));
 }
 function detectSyncDatabases(config) {
   const needsSync = /* @__PURE__ */ new Set();
@@ -371483,25 +371561,25 @@ async function waitForTcpPort4(host, port, timeoutMs = 3e4) {
     if (isOpen) {
       return;
     }
-    await new Promise((resolve52) => setTimeout(resolve52, 100));
+    await new Promise((resolve62) => setTimeout(resolve62, 100));
   }
   throw new Error(`Temporal port ${port} did not become available within timeout`);
 }
 function checkTcpPort4(host, port) {
-  return new Promise((resolve52) => {
+  return new Promise((resolve62) => {
     const socket = new net5.Socket();
     socket.setTimeout(1e3);
     socket.on("connect", () => {
       socket.destroy();
-      resolve52(true);
+      resolve62(true);
     });
     socket.on("timeout", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.on("error", () => {
       socket.destroy();
-      resolve52(false);
+      resolve62(false);
     });
     socket.connect(port, host);
   });
@@ -371763,6 +371841,80 @@ function watchConfigFile(configPath, debounceMs, onChange) {
     }
   };
 }
+var MAX_BYTES = 1024 * 1024;
+var TAIL_BYTES = 512 * 1024;
+var ServiceLogFiles = class {
+  _logsDir;
+  files = /* @__PURE__ */ new Map();
+  constructor(projectDir, instanceKey) {
+    this._logsDir = path13.resolve(
+      projectDir,
+      ".specific",
+      "keys",
+      instanceKey,
+      "logs"
+    );
+    fs12.mkdirSync(this._logsDir, { recursive: true });
+  }
+  get logsDir() {
+    return this._logsDir;
+  }
+  write(line) {
+    const file = this.getOrCreate(line.service);
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const text = `[${timestamp}] [${line.stream}] ${line.text}
+`;
+    const bytes = Buffer.byteLength(text);
+    file.stream.write(text);
+    file.bytes += bytes;
+    if (file.bytes > MAX_BYTES) {
+      this.rotate(line.service, file);
+    }
+  }
+  close() {
+    for (const file of this.files.values()) {
+      file.stream.end();
+    }
+    this.files.clear();
+  }
+  getOrCreate(service) {
+    const existing = this.files.get(service);
+    if (existing) return existing;
+    const filePath = path13.join(this._logsDir, `${service}.log`);
+    let initialBytes = 0;
+    try {
+      initialBytes = fs12.statSync(filePath).size;
+    } catch {
+    }
+    const file = {
+      filePath,
+      stream: fs12.createWriteStream(filePath, { flags: "a" }),
+      bytes: initialBytes
+    };
+    this.files.set(service, file);
+    return file;
+  }
+  rotate(service, file) {
+    file.stream.end();
+    this.files.delete(service);
+    try {
+      const buf = fs12.readFileSync(file.filePath);
+      const start = Math.max(0, buf.length - TAIL_BYTES);
+      let cut = start;
+      if (start > 0) {
+        const nl = buf.indexOf(10, start);
+        cut = nl >= 0 ? nl + 1 : buf.length;
+      }
+      const tail = buf.subarray(cut);
+      fs12.writeFileSync(file.filePath, tail);
+    } catch {
+      try {
+        fs12.unlinkSync(file.filePath);
+      } catch {
+      }
+    }
+  }
+};
 var BLOCK_SIZE = 100;
 var FIRST_BLOCK_START = 3e3;
 var MAX_BLOCKS = 100;
@@ -371821,11 +371973,11 @@ var BlockPortAllocator = class _BlockPortAllocator {
   }
 };
 function isPortAvailable(port) {
-  return new Promise((resolve52) => {
+  return new Promise((resolve62) => {
     const server = net6.createServer();
-    server.once("error", () => resolve52(false));
+    server.once("error", () => resolve62(false));
     server.once("listening", () => {
-      server.close(() => resolve52(true));
+      server.close(() => resolve62(true));
     });
     server.listen(port, "127.0.0.1");
   });
@@ -371835,16 +371987,16 @@ var StableSubdomainAllocator = class {
   tunnelsFilePath;
   baseSlug = null;
   constructor(projectRoot, key = "default") {
-    this.tunnelsDir = path13.join(projectRoot, ".specific", "keys", key);
-    this.tunnelsFilePath = path13.join(this.tunnelsDir, "tunnels.json");
+    this.tunnelsDir = path14.join(projectRoot, ".specific", "keys", key);
+    this.tunnelsFilePath = path14.join(this.tunnelsDir, "tunnels.json");
     this.loadTunnels();
   }
   loadTunnels() {
-    if (!fs12.existsSync(this.tunnelsFilePath)) {
+    if (!fs13.existsSync(this.tunnelsFilePath)) {
       return;
     }
     try {
-      const content = fs12.readFileSync(this.tunnelsFilePath, "utf-8");
+      const content = fs13.readFileSync(this.tunnelsFilePath, "utf-8");
       const data = JSON.parse(content);
       if (data.version === 1 && data.baseSlug) {
         this.baseSlug = data.baseSlug;
@@ -371854,14 +372006,14 @@ var StableSubdomainAllocator = class {
     }
   }
   saveTunnels() {
-    if (!fs12.existsSync(this.tunnelsDir)) {
-      fs12.mkdirSync(this.tunnelsDir, { recursive: true });
+    if (!fs13.existsSync(this.tunnelsDir)) {
+      fs13.mkdirSync(this.tunnelsDir, { recursive: true });
     }
     const data = {
       version: 1,
       baseSlug: this.baseSlug
     };
-    fs12.writeFileSync(this.tunnelsFilePath, JSON.stringify(data, null, 2));
+    fs13.writeFileSync(this.tunnelsFilePath, JSON.stringify(data, null, 2));
   }
   generateBaseSlug() {
     return generateSlug(2, {
@@ -372147,6 +372299,7 @@ var DevEnvironment = class extends TypedEventEmitter {
   startTime = null;
   // Core managers
   stateManager = null;
+  serviceLogFiles = null;
   // Running instances
   adminServer = null;
   services = [];
@@ -372201,6 +372354,7 @@ var DevEnvironment = class extends TypedEventEmitter {
   }
   // ── Log helper ─────────────────────────────────────────────────────────────
   addLog(line) {
+    this.serviceLogFiles?.write(line);
     this.emit("log", { service: line.service, text: line.text });
   }
   // ── Public methods ─────────────────────────────────────────────────────────
@@ -372213,8 +372367,8 @@ var DevEnvironment = class extends TypedEventEmitter {
     this.started = true;
     this.shuttingDown = false;
     this.cancelled = false;
-    return new Promise((resolve52) => {
-      this.startResolve = resolve52;
+    return new Promise((resolve62) => {
+      this.startResolve = resolve62;
       this.startInternal().then(() => {
         if (this.startResolve) {
           this.startResolve();
@@ -372395,6 +372549,8 @@ var DevEnvironment = class extends TypedEventEmitter {
     this.restartServices = null;
     this.removeExitHandler();
     this.systemLog("Shutdown complete");
+    this.serviceLogFiles?.close();
+    this.serviceLogFiles = null;
     closeDebugLog();
     this.setStatus("idle");
     this.emit("stopped");
@@ -372466,10 +372622,10 @@ var DevEnvironment = class extends TypedEventEmitter {
   }
   // ── Private: config file watcher ───────────────────────────────────────────
   startConfigWatcher() {
-    const configPath = path14.join(this.projectDir, "specific.hcl");
+    const configPath = path15.join(this.projectDir, "specific.hcl");
     this.configWatcher = watchConfigFile(configPath, 1e3, () => {
       try {
-        const hcl = fs13.readFileSync(configPath, "utf-8");
+        const hcl = fs14.readFileSync(configPath, "utf-8");
         parseConfig(hcl).then(() => {
           this.reload();
         }).catch((err) => {
@@ -372490,6 +372646,12 @@ var DevEnvironment = class extends TypedEventEmitter {
       this.instanceKey
     );
     this.stateManager = stateManager;
+    if (!this.serviceLogFiles) {
+      this.serviceLogFiles = new ServiceLogFiles(
+        this.projectDir,
+        this.instanceKey
+      );
+    }
     this.systemLog("Starting dev server");
     this.setStatus("loading");
     await stateManager.cleanStaleState();
@@ -372508,8 +372670,8 @@ var DevEnvironment = class extends TypedEventEmitter {
       this.emit("error", new Error(msg));
       return;
     }
-    const configPath = path14.join(this.projectDir, "specific.hcl");
-    if (!fs13.existsSync(configPath)) {
+    const configPath = path15.join(this.projectDir, "specific.hcl");
+    if (!fs14.existsSync(configPath)) {
       this.systemLog("Waiting for specific.hcl to appear");
       this.setStatus("waiting");
       const dirWatcher = chokidar_default.watch(configPath, {
@@ -372530,7 +372692,7 @@ var DevEnvironment = class extends TypedEventEmitter {
       return;
     }
     let config;
-    const hcl = fs13.readFileSync(configPath, "utf-8");
+    const hcl = fs14.readFileSync(configPath, "utf-8");
     try {
       config = await parseConfig(hcl);
     } catch (err) {
@@ -372540,9 +372702,9 @@ var DevEnvironment = class extends TypedEventEmitter {
       return;
     }
     if (this.cancelled) return;
-    const localFilePath = path14.join(this.projectDir, "specific.local");
-    if (fs13.existsSync(localFilePath)) {
-      const localContent = fs13.readFileSync(localFilePath, "utf-8");
+    const localFilePath = path15.join(this.projectDir, "specific.local");
+    if (fs14.existsSync(localFilePath)) {
+      const localContent = fs14.readFileSync(localFilePath, "utf-8");
       try {
         await parseLocalFile(localContent);
       } catch (err) {
@@ -372660,7 +372822,7 @@ var DevEnvironment = class extends TypedEventEmitter {
         const drizzleGateway = await startDrizzleGateway(
           postgresResources,
           drizzlePort,
-          path14.join(this.projectDir, ".specific", "keys", this.instanceKey)
+          path15.join(this.projectDir, ".specific", "keys", this.instanceKey)
         );
         this.drizzleGateway = drizzleGateway;
         this.systemLog(`Database viewer ready at ${drizzleGateway.url}`);
@@ -372687,14 +372849,14 @@ var DevEnvironment = class extends TypedEventEmitter {
       if (pg.reshape?.enabled) {
         const resource = resources.get(pg.name);
         if (!resource) continue;
-        const migrationsDir = path14.resolve(
+        const migrationsDir = path15.resolve(
           this.projectDir,
           pg.reshape.migrations_dir ?? "migrations"
         );
         this.systemLog(
           `Initializing Reshape migrations for "${pg.name}" from ${migrationsDir}`
         );
-        const reshapeStateFile = path14.join(
+        const reshapeStateFile = path15.join(
           this.projectDir,
           ".specific",
           "keys",
@@ -372798,8 +372960,8 @@ var DevEnvironment = class extends TypedEventEmitter {
         if (missingConfigs.length > 0) {
           this.emit("inputRequired", "configs", missingConfigs);
         }
-        await new Promise((resolve52) => {
-          this.inputResolve = resolve52;
+        await new Promise((resolve62) => {
+          this.inputResolve = resolve62;
           this.checkInputComplete();
         });
         for (const [name, value] of Object.entries(this.collectedSecrets)) {
@@ -372907,13 +373069,13 @@ Add them to the config block in specific.local`
     const runningServices = [];
     const resolveServiceCwd = (service) => {
       if (service.root)
-        return path14.resolve(this.projectDir, service.root);
+        return path15.resolve(this.projectDir, service.root);
       if (service.build) {
         const build = config.builds.find(
           (b) => b.name === service.build.name
         );
         if (build?.root)
-          return path14.resolve(this.projectDir, build.root);
+          return path15.resolve(this.projectDir, build.root);
       }
       return this.projectDir;
     };
@@ -372933,7 +373095,7 @@ Add them to the config block in specific.local`
         const volumePaths = /* @__PURE__ */ new Map();
         if (service.volumes) {
           for (const vol of service.volumes) {
-            const volumeDir = path14.resolve(
+            const volumeDir = path15.resolve(
               this.projectDir,
               ".specific",
               "keys",
@@ -372943,7 +373105,7 @@ Add them to the config block in specific.local`
               service.name,
               vol.name
             );
-            fs13.mkdirSync(volumeDir, { recursive: true });
+            fs14.mkdirSync(volumeDir, { recursive: true });
             volumePaths.set(vol.name, volumeDir);
           }
         }
@@ -372993,7 +373155,7 @@ Add them to the config block in specific.local`
           const volumePaths = /* @__PURE__ */ new Map();
           if (service.volumes) {
             for (const vol of service.volumes) {
-              const volumeDir = path14.resolve(
+              const volumeDir = path15.resolve(
                 this.projectDir,
                 ".specific",
                 "keys",
@@ -373003,7 +373165,7 @@ Add them to the config block in specific.local`
                 service.name,
                 vol.name
               );
-              fs13.mkdirSync(volumeDir, { recursive: true });
+              fs14.mkdirSync(volumeDir, { recursive: true });
               volumePaths.set(vol.name, volumeDir);
             }
           }
@@ -373150,7 +373312,11 @@ Add them to the config block in specific.local`
       ...temporalUiPort !== void 0 ? { temporalUiPort } : {}
     });
     const adminPort = portAllocator.getAdminPort();
-    const adminServer = await startAdminServer(getState, adminPort);
+    const adminServer = await startAdminServer(
+      getState,
+      adminPort,
+      () => this.serviceLogFiles?.logsDir ?? null
+    );
     this.adminServer = adminServer;
     this.systemLog(
       `Admin server started on port ${adminServer.port}`
@@ -373173,8 +373339,8 @@ function isInWorktree() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    const resolvedCommonDir = path15.resolve(commonDir);
-    const resolvedGitDir = path15.resolve(gitDir);
+    const resolvedCommonDir = path16.resolve(commonDir);
+    const resolvedGitDir = path16.resolve(gitDir);
     return resolvedCommonDir !== resolvedGitDir;
   } catch {
     return false;
@@ -373189,7 +373355,7 @@ function getWorktreeName() {
       encoding: "utf-8",
       stdio: ["pipe", "pipe", "pipe"]
     }).trim();
-    return path15.basename(gitDir);
+    return path16.basename(gitDir);
   } catch {
     return null;
   }
@@ -373288,8 +373454,8 @@ function findEnvironmentByNameOrId(environments, flag) {
 }
 
 // src/lib/auth/credentials.ts
-import * as fs19 from "fs";
-import * as path17 from "path";
+import * as fs20 from "fs";
+import * as path18 from "path";
 import * as os4 from "os";
 
 // src/lib/auth/errors.ts
@@ -373459,7 +373625,7 @@ async function pollUntilToken(deviceAuth, isCancelled) {
   return null;
 }
 function sleep4(ms) {
-  return new Promise((resolve9) => setTimeout(resolve9, ms));
+  return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 
 // src/lib/auth/login.tsx
@@ -373476,7 +373642,7 @@ function LoginUI({
   return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", gap: 1 }, isReauthentication && /* @__PURE__ */ React.createElement(Text, { color: "yellow" }, "Session expired. Please log in again."), /* @__PURE__ */ React.createElement(Text, { bold: true }, "Log in to Specific"), state.phase === "waiting-for-browser" ? /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Text, null, "Your authentication code:", " ", /* @__PURE__ */ React.createElement(Text, { color: "cyan", bold: true }, state.userCode))), /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, /* @__PURE__ */ React.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React.createElement(Text, null, " Waiting for authentication in browser...")), /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "If the browser didn't open, visit: ", state.verificationUri)) : /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { color: "blue" }, /* @__PURE__ */ React.createElement(Spinner, { type: "dots" })), /* @__PURE__ */ React.createElement(Text, null, " Initiating login...")));
 }
 function performLogin(options2 = {}) {
-  return new Promise((resolve9) => {
+  return new Promise((resolve10) => {
     let currentState = { phase: "initiating" };
     let flowHandle;
     const instance = render(
@@ -373516,14 +373682,14 @@ function performLogin(options2 = {}) {
             process.off("SIGINT", handleExit);
             process.off("SIGTERM", handleExit);
             instance.unmount();
-            resolve9({ success: true, userEmail: newState.email });
+            resolve10({ success: true, userEmail: newState.email });
           }, 100);
         } else if (newState.phase === "error") {
           setTimeout(() => {
             process.off("SIGINT", handleExit);
             process.off("SIGTERM", handleExit);
             instance.unmount();
-            resolve9({ success: false, error: new Error(newState.message) });
+            resolve10({ success: false, error: new Error(newState.message) });
           }, 100);
         }
       }
@@ -373614,18 +373780,18 @@ async function fetchGithubActionsIdToken() {
 
 // src/lib/auth/credentials.ts
 function getUserCredentialsDir() {
-  return path17.join(os4.homedir(), ".specific");
+  return path18.join(os4.homedir(), ".specific");
 }
 function getCredentialsPath() {
-  return path17.join(getUserCredentialsDir(), "credentials.json");
+  return path18.join(getUserCredentialsDir(), "credentials.json");
 }
 function readUserCredentials() {
   const credentialsPath = getCredentialsPath();
-  if (!fs19.existsSync(credentialsPath)) {
+  if (!fs20.existsSync(credentialsPath)) {
     return null;
   }
   try {
-    const content = fs19.readFileSync(credentialsPath, "utf-8");
+    const content = fs20.readFileSync(credentialsPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -373633,18 +373799,18 @@ function readUserCredentials() {
 }
 function writeUserCredentials(credentials) {
   const dir = getUserCredentialsDir();
-  if (!fs19.existsSync(dir)) {
-    fs19.mkdirSync(dir, { recursive: true, mode: 448 });
+  if (!fs20.existsSync(dir)) {
+    fs20.mkdirSync(dir, { recursive: true, mode: 448 });
   }
   const credentialsPath = getCredentialsPath();
-  fs19.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
+  fs20.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2), {
     mode: 384
   });
 }
 function clearUserCredentials() {
   const credentialsPath = getCredentialsPath();
-  if (fs19.existsSync(credentialsPath)) {
-    fs19.unlinkSync(credentialsPath);
+  if (fs20.existsSync(credentialsPath)) {
+    fs20.unlinkSync(credentialsPath);
   }
 }
 function isLoggedIn() {
@@ -373773,7 +373939,7 @@ function trackEvent(event, properties) {
     event,
     properties: {
       ...properties,
-      cli_version: "0.1.140",
+      cli_version: "0.1.142",
       platform: process.platform,
       node_version: process.version,
       project_id: getProjectId()
@@ -373804,67 +373970,67 @@ var options = [
   { id: "other", label: "Other / Manual" }
 ];
 function isGitProject() {
-  const gitPath = path18.join(process.cwd(), ".git");
-  return fs20.existsSync(gitPath);
+  const gitPath = path19.join(process.cwd(), ".git");
+  return fs21.existsSync(gitPath);
 }
 function detectExistingAgents() {
   const detected = {};
-  const cursorDir = path18.join(process.cwd(), ".cursor");
-  if (fs20.existsSync(cursorDir)) {
+  const cursorDir = path19.join(process.cwd(), ".cursor");
+  if (fs21.existsSync(cursorDir)) {
     detected["cursor"] = true;
   }
-  const claudeDir = path18.join(process.cwd(), ".claude");
-  const claudeMd = path18.join(process.cwd(), "CLAUDE.md");
-  if (fs20.existsSync(claudeDir) || fs20.existsSync(claudeMd)) {
+  const claudeDir = path19.join(process.cwd(), ".claude");
+  const claudeMd = path19.join(process.cwd(), "CLAUDE.md");
+  if (fs21.existsSync(claudeDir) || fs21.existsSync(claudeMd)) {
     detected["claude"] = true;
   }
-  const agentsMd = path18.join(process.cwd(), "AGENTS.md");
-  if (fs20.existsSync(agentsMd)) {
+  const agentsMd = path19.join(process.cwd(), "AGENTS.md");
+  if (fs21.existsSync(agentsMd)) {
     detected["codex"] = true;
   }
   return detected;
 }
 function appendOrCreateFile(filePath, content) {
-  if (fs20.existsSync(filePath)) {
-    const existing = fs20.readFileSync(filePath, "utf-8");
+  if (fs21.existsSync(filePath)) {
+    const existing = fs21.readFileSync(filePath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
     const separator = existing.endsWith("\n") ? "\n" : "\n\n";
-    fs20.writeFileSync(filePath, existing + separator + content + "\n");
+    fs21.writeFileSync(filePath, existing + separator + content + "\n");
     return "modified";
   } else {
-    fs20.writeFileSync(filePath, content + "\n");
+    fs21.writeFileSync(filePath, content + "\n");
     return "created";
   }
 }
 function addToGitignore() {
-  const gitignorePath = path18.join(process.cwd(), ".gitignore");
+  const gitignorePath = path19.join(process.cwd(), ".gitignore");
   const entries = [".specific", "specific.local"];
-  if (fs20.existsSync(gitignorePath)) {
-    const existing = fs20.readFileSync(gitignorePath, "utf-8");
+  if (fs21.existsSync(gitignorePath)) {
+    const existing = fs21.readFileSync(gitignorePath, "utf-8");
     const lines = existing.split("\n").map((l) => l.trim());
     const missingEntries = entries.filter((entry) => !lines.includes(entry));
     if (missingEntries.length === 0) {
       return "unchanged";
     }
     const separator = existing.endsWith("\n") ? "" : "\n";
-    fs20.writeFileSync(
+    fs21.writeFileSync(
       gitignorePath,
       existing + separator + missingEntries.join("\n") + "\n"
     );
     return "modified";
   } else {
-    fs20.writeFileSync(gitignorePath, entries.join("\n") + "\n");
+    fs21.writeFileSync(gitignorePath, entries.join("\n") + "\n");
     return "created";
   }
 }
 function configureClaudeCodePermissions() {
-  const claudeDir = path18.join(process.cwd(), ".claude");
-  const settingsPath = path18.join(claudeDir, "settings.local.json");
+  const claudeDir = path19.join(process.cwd(), ".claude");
+  const settingsPath = path19.join(claudeDir, "settings.local.json");
   const permissions = ["Bash(specific docs:*)", "Bash(specific check:*)"];
-  if (fs20.existsSync(settingsPath)) {
-    const existing = JSON.parse(fs20.readFileSync(settingsPath, "utf-8"));
+  if (fs21.existsSync(settingsPath)) {
+    const existing = JSON.parse(fs21.readFileSync(settingsPath, "utf-8"));
     const allowList = existing?.permissions?.allow || [];
     const missingPermissions = permissions.filter(
       (p) => !allowList.includes(p)
@@ -373879,39 +374045,39 @@ function configureClaudeCodePermissions() {
       existing.permissions.allow = [];
     }
     existing.permissions.allow.push(...missingPermissions);
-    fs20.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+    fs21.writeFileSync(settingsPath, JSON.stringify(existing, null, 2) + "\n");
     return "modified";
   }
-  if (!fs20.existsSync(claudeDir)) {
-    fs20.mkdirSync(claudeDir);
+  if (!fs21.existsSync(claudeDir)) {
+    fs21.mkdirSync(claudeDir);
   }
   const settings = {
     permissions: {
       allow: permissions
     }
   };
-  fs20.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+  fs21.writeFileSync(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return "created";
 }
 function createCursorRule() {
-  const cursorDir = path18.join(process.cwd(), ".cursor");
-  const rulesDir = path18.join(cursorDir, "rules");
-  const mdcPath = path18.join(rulesDir, "specific.mdc");
-  if (fs20.existsSync(mdcPath)) {
-    const existing = fs20.readFileSync(mdcPath, "utf-8");
+  const cursorDir = path19.join(process.cwd(), ".cursor");
+  const rulesDir = path19.join(cursorDir, "rules");
+  const mdcPath = path19.join(rulesDir, "specific.mdc");
+  if (fs21.existsSync(mdcPath)) {
+    const existing = fs21.readFileSync(mdcPath, "utf-8");
     if (existing.includes("specific docs") || existing.includes("specific check")) {
       return "unchanged";
     }
-    fs20.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+    fs21.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
     return "modified";
   }
-  if (!fs20.existsSync(cursorDir)) {
-    fs20.mkdirSync(cursorDir);
+  if (!fs21.existsSync(cursorDir)) {
+    fs21.mkdirSync(cursorDir);
   }
-  if (!fs20.existsSync(rulesDir)) {
-    fs20.mkdirSync(rulesDir);
+  if (!fs21.existsSync(rulesDir)) {
+    fs21.mkdirSync(rulesDir);
   }
-  fs20.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
+  fs21.writeFileSync(mdcPath, CURSOR_MDC_CONTENT);
   return "created";
 }
 function configureAgents(checked) {
@@ -373927,7 +374093,7 @@ function configureAgents(checked) {
       agents.filesModified.push(".cursor/rules/specific.mdc");
   }
   if (checked["claude"]) {
-    const claudeMdPath = path18.join(process.cwd(), "CLAUDE.md");
+    const claudeMdPath = path19.join(process.cwd(), "CLAUDE.md");
     const status = appendOrCreateFile(claudeMdPath, SPECIFIC_INSTRUCTIONS);
     if (status === "created") agents.filesCreated.push("CLAUDE.md");
     else if (status === "modified") agents.filesModified.push("CLAUDE.md");
@@ -373938,7 +374104,7 @@ function configureAgents(checked) {
       agents.filesModified.push(".claude/settings.local.json");
   }
   if (checked["codex"]) {
-    const agentsMdPath = path18.join(process.cwd(), "AGENTS.md");
+    const agentsMdPath = path19.join(process.cwd(), "AGENTS.md");
     const status = appendOrCreateFile(agentsMdPath, SPECIFIC_INSTRUCTIONS);
     if (status === "created") agents.filesCreated.push("AGENTS.md");
     else if (status === "modified") agents.filesModified.push("AGENTS.md");
@@ -374091,9 +374257,9 @@ Valid agents: ${VALID_AGENT_IDS.join(", ")}`
 }
 
 // src/commands/docs.tsx
-import { readFileSync as readFileSync11, existsSync as existsSync17 } from "fs";
+import { readFileSync as readFileSync12, existsSync as existsSync17 } from "fs";
 import { spawn as spawn6 } from "child_process";
-import { join as join19, dirname as dirname9 } from "path";
+import { join as join20, dirname as dirname9 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/lib/beta/registry.ts
@@ -374105,16 +374271,16 @@ var BETA_REGISTRY = [
 ];
 
 // src/lib/beta/storage.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, existsSync as existsSync16, mkdirSync as mkdirSync13 } from "fs";
-import { join as join18 } from "path";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, existsSync as existsSync16, mkdirSync as mkdirSync14 } from "fs";
+import { join as join19 } from "path";
 var BETAS_FILE = ".specific/betas.json";
 function loadEnabledBetas(projectDir = process.cwd()) {
-  const filePath = join18(projectDir, BETAS_FILE);
+  const filePath = join19(projectDir, BETAS_FILE);
   if (!existsSync16(filePath)) {
     return [];
   }
   try {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     const data = JSON.parse(content);
     return data.enabled ?? [];
   } catch {
@@ -374133,30 +374299,30 @@ function disableBeta(name, projectDir = process.cwd()) {
   saveBetas(enabled, projectDir);
 }
 function saveBetas(enabled, projectDir) {
-  const specificDir = join18(projectDir, ".specific");
+  const specificDir = join19(projectDir, ".specific");
   if (!existsSync16(specificDir)) {
-    mkdirSync13(specificDir, { recursive: true });
+    mkdirSync14(specificDir, { recursive: true });
   }
   const data = { enabled };
-  writeFileSync8(
-    join18(projectDir, BETAS_FILE),
+  writeFileSync9(
+    join19(projectDir, BETAS_FILE),
     JSON.stringify(data, null, 2) + "\n"
   );
 }
 
 // src/commands/docs.tsx
 var __dirname3 = dirname9(fileURLToPath3(import.meta.url));
-var docsDir = join19(__dirname3, "docs");
+var docsDir = join20(__dirname3, "docs");
 var _embeddedDocs = null;
 var RESHAPE_DOCS_PREFIX = "postgres/reshape/";
-async function docsCommand(path27) {
-  let content = resolveDocContent(path27);
-  if (!content && path27) {
-    content = await resolveReshapeDoc(path27);
+async function docsCommand(path28) {
+  let content = resolveDocContent(path28);
+  if (!content && path28) {
+    content = await resolveReshapeDoc(path28);
   }
   if (!content) {
     console.error(
-      `Documentation not found: ${path27 || "index"}
+      `Documentation not found: ${path28 || "index"}
 
 Run 'specific docs' to see available topics.`
     );
@@ -374166,25 +374332,25 @@ Run 'specific docs' to see available topics.`
   const filtered = filterBetaTags(content, enabledBetas);
   console.log(filtered);
 }
-async function resolveReshapeDoc(path27) {
-  const normalized = path27.replace(/^\/+|\/+$/g, "");
+async function resolveReshapeDoc(path28) {
+  const normalized = path28.replace(/^\/+|\/+$/g, "");
   if (!normalized.startsWith(RESHAPE_DOCS_PREFIX)) return null;
   const reshapePath = "/" + normalized.slice(RESHAPE_DOCS_PREFIX.length);
   try {
     const binary = await ensureBinary(reshapeBinary);
     const reshapeExe = binary.executables["reshape"];
-    const output = await new Promise((resolve9) => {
+    const output = await new Promise((resolve10) => {
       const child = spawn6(reshapeExe, ["docs", reshapePath], {
         stdio: ["ignore", "pipe", "ignore"]
       });
       const chunks = [];
       child.stdout.on("data", (chunk) => chunks.push(chunk));
-      child.on("error", () => resolve9(null));
+      child.on("error", () => resolve10(null));
       child.on("close", (code) => {
         if (code === 0 && chunks.length > 0) {
-          resolve9(Buffer.concat(chunks).toString("utf-8"));
+          resolve10(Buffer.concat(chunks).toString("utf-8"));
         } else {
-          resolve9(null);
+          resolve10(null);
         }
       });
     });
@@ -374201,33 +374367,33 @@ function filterBetaTags(content, enabledBetas) {
     }
   );
 }
-function resolveDocContent(path27) {
-  const normalized = path27?.replace(/^\/+|\/+$/g, "") || void 0;
+function resolveDocContent(path28) {
+  const normalized = path28?.replace(/^\/+|\/+$/g, "") || void 0;
   if (_embeddedDocs) {
     return resolveEmbeddedDoc(normalized);
   }
   return resolveFilesystemDoc(normalized);
 }
-function resolveEmbeddedDoc(path27) {
-  if (!path27) {
+function resolveEmbeddedDoc(path28) {
+  if (!path28) {
     return _embeddedDocs.get("index.md") ?? null;
   }
-  const direct = _embeddedDocs.get(`${path27}.md`);
+  const direct = _embeddedDocs.get(`${path28}.md`);
   if (direct) return direct;
-  return _embeddedDocs.get(`${path27}/index.md`) ?? null;
+  return _embeddedDocs.get(`${path28}/index.md`) ?? null;
 }
-function resolveFilesystemDoc(path27) {
-  if (!path27) {
-    const indexPath2 = join19(docsDir, "index.md");
-    return existsSync17(indexPath2) ? readFileSync11(indexPath2, "utf-8") : null;
+function resolveFilesystemDoc(path28) {
+  if (!path28) {
+    const indexPath2 = join20(docsDir, "index.md");
+    return existsSync17(indexPath2) ? readFileSync12(indexPath2, "utf-8") : null;
   }
-  const directPath = join19(docsDir, `${path27}.md`);
+  const directPath = join20(docsDir, `${path28}.md`);
   if (existsSync17(directPath)) {
-    return readFileSync11(directPath, "utf-8");
+    return readFileSync12(directPath, "utf-8");
   }
-  const indexPath = join19(docsDir, path27, "index.md");
+  const indexPath = join20(docsDir, path28, "index.md");
   if (existsSync17(indexPath)) {
-    return readFileSync11(indexPath, "utf-8");
+    return readFileSync12(indexPath, "utf-8");
   }
   return null;
 }
@@ -374236,8 +374402,8 @@ function resolveFilesystemDoc(path27) {
 import React3, { useState as useState2, useEffect as useEffect2 } from "react";
 import { render as render3, Text as Text3, Box as Box3 } from "ink";
 import Spinner2 from "ink-spinner";
-import * as fs21 from "fs";
-import * as path19 from "path";
+import * as fs22 from "fs";
+import * as path20 from "path";
 import { execFile as execFile8 } from "child_process";
 
 // node_modules/.pnpm/@specific+config@file+..+config/node_modules/@specific/config/dist/parser.js
@@ -374891,13 +375057,13 @@ async function runReshapeCheck(migrationsDir) {
   try {
     const binary = await ensureBinary(reshapeBinary);
     const reshapePath = binary.executables["reshape"];
-    return new Promise((resolve9) => {
+    return new Promise((resolve10) => {
       execFile8(reshapePath, ["check", "--dirs", migrationsDir], (err, _stdout, stderr) => {
         if (err) {
           const errorMsg = stderr.trim() || err.message;
-          resolve9({ success: false, error: errorMsg });
+          resolve10({ success: false, error: errorMsg });
         } else {
-          resolve9({ success: true });
+          resolve10({ success: true });
         }
       });
     });
@@ -374909,20 +375075,20 @@ function CheckUI() {
   const [state, setState] = useState2({ status: "loading" });
   useEffect2(() => {
     async function load() {
-      const configPath = path19.join(process.cwd(), "specific.hcl");
-      if (!fs21.existsSync(configPath)) {
+      const configPath = path20.join(process.cwd(), "specific.hcl");
+      if (!fs22.existsSync(configPath)) {
         setState({
           status: "error",
           error: "No specific.hcl found in current directory"
         });
         return;
       }
-      const hcl = fs21.readFileSync(configPath, "utf-8");
+      const hcl = fs22.readFileSync(configPath, "utf-8");
       try {
         const config2 = await parseConfig2(hcl);
-        const localPath = path19.join(process.cwd(), LOCAL_FILE);
-        if (fs21.existsSync(localPath)) {
-          const localContent = fs21.readFileSync(localPath, "utf-8");
+        const localPath = path20.join(process.cwd(), LOCAL_FILE);
+        if (fs22.existsSync(localPath)) {
+          const localContent = fs22.readFileSync(localPath, "utf-8");
           try {
             await parseLocalFile(localContent);
           } catch (localErr) {
@@ -374935,8 +375101,8 @@ function CheckUI() {
         }
         for (const build of config2.builds) {
           if (build.dockerfile) {
-            const dockerfilePath = path19.resolve(process.cwd(), build.dockerfile);
-            if (!fs21.existsSync(dockerfilePath)) {
+            const dockerfilePath = path20.resolve(process.cwd(), build.dockerfile);
+            if (!fs22.existsSync(dockerfilePath)) {
               setState({
                 status: "error",
                 error: `Build "${build.name}": Dockerfile not found at "${build.dockerfile}" (resolved to ${dockerfilePath})`
@@ -374948,11 +375114,11 @@ function CheckUI() {
         const reshapeChecks2 = [];
         for (const pg of config2.postgres) {
           if (pg.reshape?.enabled) {
-            const migrationsDir = path19.resolve(
+            const migrationsDir = path20.resolve(
               process.cwd(),
               pg.reshape.migrations_dir ?? "migrations"
             );
-            if (!fs21.existsSync(migrationsDir)) {
+            if (!fs22.existsSync(migrationsDir)) {
               reshapeChecks2.push({
                 databaseName: pg.name,
                 migrationsDir: pg.reshape.migrations_dir ?? "migrations",
@@ -375621,8 +375787,8 @@ init_open();
 import React7, { useState as useState6, useEffect as useEffect6, useCallback as useCallback3 } from "react";
 import { render as render5, Text as Text7, Box as Box7, useApp as useApp3, useInput as useInput4 } from "ink";
 import Spinner4 from "ink-spinner";
-import * as fs22 from "fs";
-import * as path20 from "path";
+import * as fs23 from "fs";
+import * as path21 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
 function getGitInfo(cwd) {
   try {
@@ -376861,7 +377027,7 @@ async function runDeployPipeline(options2) {
   }
   console.log("Waiting for build...");
   while (true) {
-    await new Promise((resolve9) => setTimeout(resolve9, 2e3));
+    await new Promise((resolve10) => setTimeout(resolve10, 2e3));
     const status = await client2.getDeployment(deployment.id);
     deployment = status;
     if (status.state === "failed") {
@@ -376936,7 +377102,7 @@ ${failedBuild.output}`);
   }
   console.log("Deploying...");
   while (true) {
-    await new Promise((resolve9) => setTimeout(resolve9, 2e3));
+    await new Promise((resolve10) => setTimeout(resolve10, 2e3));
     const status = await client2.getDeployment(deployment.id);
     deployment = status;
     if (status.state === "failed") {
@@ -376970,13 +377136,13 @@ ${status.error.output}`);
   }
 }
 async function deployCommand(options2) {
-  const configPath = path20.join(process.cwd(), "specific.hcl");
-  if (!fs22.existsSync(configPath)) {
+  const configPath = path21.join(process.cwd(), "specific.hcl");
+  if (!fs23.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
-  const hcl = fs22.readFileSync(configPath, "utf-8");
+  const hcl = fs23.readFileSync(configPath, "utf-8");
   try {
     config = await parseConfig2(hcl);
   } catch (err) {
@@ -377009,8 +377175,8 @@ async function deployCommand(options2) {
 
 // src/commands/exec.tsx
 import { spawn as spawn7 } from "child_process";
-import * as fs23 from "fs";
-import * as path21 from "path";
+import * as fs24 from "fs";
+import * as path22 from "path";
 function startSpinner(text) {
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
   let i = 0;
@@ -377051,13 +377217,13 @@ async function execCommand(serviceName, command, instanceKey = "default", option
       }
     }
   };
-  const configPath = path21.join(process.cwd(), "specific.hcl");
-  if (!fs23.existsSync(configPath)) {
+  const configPath = path22.join(process.cwd(), "specific.hcl");
+  if (!fs24.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
-  const hcl = fs23.readFileSync(configPath, "utf-8");
+  const hcl = fs24.readFileSync(configPath, "utf-8");
   try {
     config = await parseConfig2(hcl);
   } catch (err) {
@@ -377223,13 +377389,13 @@ async function execCommand(serviceName, command, instanceKey = "default", option
   process.on("SIGTERM", () => handleSignal("SIGTERM"));
   let effectiveCwd = process.cwd();
   if (options2.cwd) {
-    effectiveCwd = path21.resolve(process.cwd(), options2.cwd);
+    effectiveCwd = path22.resolve(process.cwd(), options2.cwd);
   } else if (service.root) {
-    effectiveCwd = path21.resolve(process.cwd(), service.root);
+    effectiveCwd = path22.resolve(process.cwd(), service.root);
   } else if (service.build) {
     const build = config.builds.find((b) => b.name === service.build.name);
     if (build?.root) {
-      effectiveCwd = path21.resolve(process.cwd(), build.root);
+      effectiveCwd = path22.resolve(process.cwd(), build.root);
     }
   }
   spinner?.stop();
@@ -377258,8 +377424,8 @@ async function execCommand(serviceName, command, instanceKey = "default", option
 
 // src/commands/psql.tsx
 import { spawn as spawn8 } from "child_process";
-import * as fs24 from "fs";
-import * as path22 from "path";
+import * as fs25 from "fs";
+import * as path23 from "path";
 async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []) {
   let startedResources = [];
   let ownsInstances = false;
@@ -377276,13 +377442,13 @@ async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []
       }
     }
   };
-  const configPath = path22.join(process.cwd(), "specific.hcl");
-  if (!fs24.existsSync(configPath)) {
+  const configPath = path23.join(process.cwd(), "specific.hcl");
+  if (!fs25.existsSync(configPath)) {
     console.error("Error: No specific.hcl found in current directory");
     process.exit(1);
   }
   let config;
-  const hcl = fs24.readFileSync(configPath, "utf-8");
+  const hcl = fs25.readFileSync(configPath, "utf-8");
   try {
     config = await parseConfig2(hcl);
   } catch (err) {
@@ -377407,8 +377573,8 @@ async function psqlCommand(databaseName, instanceKey = "default", extraArgs = []
 
 // src/commands/reshape.tsx
 import { spawn as spawn9 } from "child_process";
-import * as fs25 from "fs";
-import * as path23 from "path";
+import * as fs26 from "fs";
+import * as path24 from "path";
 var VALID_ACTIONS = ["start", "complete", "status", "abort", "check"];
 var MIGRATION_SUBCOMMANDS = ["start", "complete", "abort"];
 var OFFLINE_ACTIONS = ["check"];
@@ -377428,13 +377594,13 @@ async function reshapeCommand(action, databaseName, instanceKey = "default") {
     process.exit(1);
   }
   const isOfflineAction = OFFLINE_ACTIONS.includes(action);
-  const configPath = path23.join(process.cwd(), "specific.hcl");
+  const configPath = path24.join(process.cwd(), "specific.hcl");
   let config;
   let migrationsDir = "migrations";
   let targetDb;
   try {
-    if (fs25.existsSync(configPath)) {
-      const configContent = fs25.readFileSync(configPath, "utf-8");
+    if (fs26.existsSync(configPath)) {
+      const configContent = fs26.readFileSync(configPath, "utf-8");
       config = await parseConfig2(configContent);
       if (databaseName) {
         const postgresConfig = config.postgres.find((p) => p.name === databaseName);
@@ -377569,9 +377735,9 @@ async function reshapeCommand(action, databaseName, instanceKey = "default") {
   }
   const isMigrationSubcommand = MIGRATION_SUBCOMMANDS.includes(action);
   const reshapeArgs = isMigrationSubcommand ? ["migration", action] : [action];
-  const fullMigrationsPath = path23.join(process.cwd(), migrationsDir);
+  const fullMigrationsPath = path24.join(process.cwd(), migrationsDir);
   if (action === "check" || action === "start") {
-    if (fs25.existsSync(fullMigrationsPath)) {
+    if (fs26.existsSync(fullMigrationsPath)) {
       reshapeArgs.push("--dirs", fullMigrationsPath);
     } else if (action === "check") {
       console.error(`Error: Migrations directory not found: ${fullMigrationsPath}`);
@@ -377621,21 +377787,21 @@ async function reshapeCommand(action, databaseName, instanceKey = "default") {
 import React8, { useState as useState7, useEffect as useEffect7 } from "react";
 import { render as render6, Text as Text8, Box as Box8 } from "ink";
 import Spinner5 from "ink-spinner";
-import * as fs26 from "fs";
-import * as path24 from "path";
+import * as fs27 from "fs";
+import * as path25 from "path";
 function CleanUI({ instanceKey }) {
   const [state, setState] = useState7({ status: "checking" });
   useEffect7(() => {
     async function clean() {
       const projectRoot = process.cwd();
-      const specificDir = path24.join(projectRoot, ".specific");
-      if (!fs26.existsSync(specificDir)) {
+      const specificDir = path25.join(projectRoot, ".specific");
+      if (!fs27.existsSync(specificDir)) {
         setState({ status: "nothing" });
         return;
       }
       if (instanceKey) {
-        const keyDir = path24.join(specificDir, "keys", instanceKey);
-        if (!fs26.existsSync(keyDir)) {
+        const keyDir = path25.join(specificDir, "keys", instanceKey);
+        if (!fs27.existsSync(keyDir)) {
           setState({ status: "nothing" });
           return;
         }
@@ -377651,7 +377817,7 @@ function CleanUI({ instanceKey }) {
         await stateManager.cleanStaleState();
         setState({ status: "cleaning" });
         try {
-          fs26.rmSync(keyDir, { recursive: true, force: true });
+          fs27.rmSync(keyDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -377660,13 +377826,13 @@ function CleanUI({ instanceKey }) {
           });
         }
       } else {
-        const keysDir = path24.join(specificDir, "keys");
-        if (!fs26.existsSync(keysDir)) {
+        const keysDir = path25.join(specificDir, "keys");
+        if (!fs27.existsSync(keysDir)) {
           setState({ status: "nothing" });
           return;
         }
-        const keys = fs26.readdirSync(keysDir).filter(
-          (f) => fs26.statSync(path24.join(keysDir, f)).isDirectory()
+        const keys = fs27.readdirSync(keysDir).filter(
+          (f) => fs27.statSync(path25.join(keysDir, f)).isDirectory()
         );
         for (const key of keys) {
           const stateManager2 = new InstanceStateManager(projectRoot, key);
@@ -377690,7 +377856,7 @@ function CleanUI({ instanceKey }) {
         }
         setState({ status: "cleaning" });
         try {
-          fs26.rmSync(keysDir, { recursive: true, force: true });
+          fs27.rmSync(keysDir, { recursive: true, force: true });
           setState({ status: "success" });
         } catch (err) {
           setState({
@@ -377869,8 +378035,8 @@ import { render as render9, Text as Text11, Box as Box10, useApp as useApp6 } fr
 import Spinner6 from "ink-spinner";
 
 // src/lib/update.ts
-import * as fs27 from "fs";
-import * as path25 from "path";
+import * as fs28 from "fs";
+import * as path26 from "path";
 var BINARIES_BASE_URL = "https://binaries.specific.dev/cli";
 function compareVersions(a, b) {
   const partsA = a.split(".").map(Number);
@@ -377884,7 +378050,7 @@ function compareVersions(a, b) {
   return 0;
 }
 async function checkForUpdate() {
-  const currentVersion = "0.1.140";
+  const currentVersion = "0.1.142";
   const response = await fetch(`${BINARIES_BASE_URL}/latest?t=${Date.now()}`);
   if (!response.ok) {
     throw new Error(`Failed to check for updates: HTTP ${response.status}`);
@@ -377898,9 +378064,9 @@ function getCurrentBinaryPath() {
 }
 function isBinaryWritable() {
   const binaryPath = getCurrentBinaryPath();
-  const dir = path25.dirname(binaryPath);
+  const dir = path26.dirname(binaryPath);
   try {
-    fs27.accessSync(dir, fs27.constants.W_OK);
+    fs28.accessSync(dir, fs28.constants.W_OK);
     return true;
   } catch {
     return false;
@@ -377908,24 +378074,24 @@ function isBinaryWritable() {
 }
 async function performUpdate(version, onProgress) {
   const binaryPath = getCurrentBinaryPath();
-  const binaryDir = path25.dirname(binaryPath);
-  const tempPath = path25.join(binaryDir, `.specific-update-${process.pid}`);
+  const binaryDir = path26.dirname(binaryPath);
+  const tempPath = path26.join(binaryDir, `.specific-update-${process.pid}`);
   try {
     const { platform: platform3, arch: arch3 } = getPlatformInfo();
     const url = `${BINARIES_BASE_URL}/${version}/specific-${platform3}-${arch3}`;
     await downloadFile(url, tempPath, onProgress);
-    const stat4 = fs27.statSync(tempPath);
+    const stat4 = fs28.statSync(tempPath);
     if (stat4.size === 0) {
       throw new Error("Downloaded binary is empty");
     }
-    fs27.chmodSync(tempPath, 493);
+    fs28.chmodSync(tempPath, 493);
     onProgress?.({ phase: "finalizing" });
-    fs27.unlinkSync(binaryPath);
-    fs27.renameSync(tempPath, binaryPath);
+    fs28.unlinkSync(binaryPath);
+    fs28.renameSync(tempPath, binaryPath);
   } catch (error) {
     try {
-      if (fs27.existsSync(tempPath)) {
-        fs27.unlinkSync(tempPath);
+      if (fs28.existsSync(tempPath)) {
+        fs28.unlinkSync(tempPath);
       }
     } catch {
     }
@@ -377935,21 +378101,21 @@ async function performUpdate(version, onProgress) {
 
 // src/lib/background-update.ts
 import { spawn as spawn10 } from "child_process";
-import * as fs28 from "fs";
-import * as path26 from "path";
+import * as fs29 from "fs";
+import * as path27 from "path";
 import * as os6 from "os";
-var SPECIFIC_DIR = path26.join(os6.homedir(), ".specific");
-var RATE_LIMIT_FILE = path26.join(SPECIFIC_DIR, "last-update-check");
-var LOCK_FILE = path26.join(SPECIFIC_DIR, "update.lock");
+var SPECIFIC_DIR = path27.join(os6.homedir(), ".specific");
+var RATE_LIMIT_FILE = path27.join(SPECIFIC_DIR, "last-update-check");
+var LOCK_FILE = path27.join(SPECIFIC_DIR, "update.lock");
 var RATE_LIMIT_MS = 60 * 60 * 1e3;
 var STALE_LOCK_MS = 10 * 60 * 1e3;
 function writeCheckTimestamp() {
-  fs28.mkdirSync(SPECIFIC_DIR, { recursive: true });
-  fs28.writeFileSync(RATE_LIMIT_FILE, String(Date.now()), "utf-8");
+  fs29.mkdirSync(SPECIFIC_DIR, { recursive: true });
+  fs29.writeFileSync(RATE_LIMIT_FILE, String(Date.now()), "utf-8");
 }
 function isRateLimited() {
   try {
-    const content = fs28.readFileSync(RATE_LIMIT_FILE, "utf-8").trim();
+    const content = fs29.readFileSync(RATE_LIMIT_FILE, "utf-8").trim();
     const lastCheck = parseInt(content, 10);
     if (isNaN(lastCheck)) return false;
     return Date.now() - lastCheck < RATE_LIMIT_MS;
@@ -378351,11 +378517,11 @@ async function resolveSql(arg) {
   return await readStdin();
 }
 async function readStdin() {
-  return new Promise((resolve9, reject) => {
+  return new Promise((resolve10, reject) => {
     let data = "";
     process.stdin.setEncoding("utf-8");
     process.stdin.on("data", (chunk) => data += chunk);
-    process.stdin.on("end", () => resolve9(data.trim()));
+    process.stdin.on("end", () => resolve10(data.trim()));
     process.stdin.on("error", reject);
   });
 }
@@ -378399,7 +378565,7 @@ function friendlyErrorMessage(raw) {
 var program = new Command();
 var env = "production";
 var envLabel = env !== "production" ? `[${env.toUpperCase()}] ` : "";
-program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.140").enablePositionalOptions();
+program.name("specific").description(`${envLabel}Infrastructure-as-code for coding agents`).version("0.1.142").enablePositionalOptions();
 program.command("init").description("Initialize project for use with a coding agent").option("--agent <name...>", "Agents to configure (cursor, claude, codex, other)").addHelpText("after", `
 Examples:
   $ specific init