npm - newcraw - Versions diffs - 1.0.2 → 1.0.3 - Mend

newcraw 1.0.2 → 1.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (220) hide show

package/dist/{chunk-IM33F5CM.js → chunk-BMJ5XGFR.js} RENAMED Viewed

@@ -1,68 +1,30 @@
 import { createRequire as __newcrawCreateRequire } from "node:module";
 const require = __newcrawCreateRequire(import.meta.url);
 import {
-  MACRO
-} from "./chunk-ZYSVG4X3.js";
-// src/utils/state/index.ts
-import { cwd } from "process";
-// src/utils/bun/shell.ts
-import { spawn } from "child_process";
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, realpathSync as realpathSync2, statSync as statSync3 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
-import { homedir as homedir2 } from "os";
-import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, resolve as resolve2 } from "path";
-import which from "which";
-// src/utils/log/index.ts
+  CONFIG_BASE_DIR,
+  PRODUCT_COMMAND,
+  init_product
+} from "./chunk-UYWZQVH5.js";
 import {
-  existsSync as existsSync2,
-  mkdirSync as mkdirSync2,
-  writeFileSync,
-  readFileSync as readFileSync2,
-  readdirSync,
-  statSync,
-  copyFileSync,
-  promises as fsPromises
-} from "fs";
-import { dirname, join as join3 } from "path";
+  MACRO,
+  init_macros
+} from "./chunk-NW7WSLD5.js";
+import {
+  __esm
+} from "./chunk-D4OZACS2.js";
 // src/services/telemetry/sentry.ts
 function initSentry() {
 }
 async function captureException(error) {
 }
-// src/utils/log/index.ts
-import { randomUUID } from "crypto";
-import envPaths from "env-paths";
-// src/constants/product.ts
-var PRODUCT_NAME = "NewCraw";
-var PROJECT_FILE = "AGENTS.md";
-var PRODUCT_COMMAND = "newcraw";
-var CONFIG_BASE_DIR = ".newcraw";
-var CONFIG_FILE = ".newcraw.json";
-var GITHUB_ISSUES_REPO_URL = "https://github.com/YOUR_USERNAME/newcraw/issues";
-var ASCII_LOGO = `
-  _   _                  ____
- | \\ | |  ___ __      __/ ___|_ __ __ ___      __
- |  \\| | / _ \\\\ \\ /\\ / / |   | '__/ _\` \\ \\ /\\ / /
- | |\\  ||  __/ \\ V  V /| |___| | | (_| |\\ V  V /
- |_| \\_| \\___|  \\_/\\_/  \\____|_|  \\__,_| \\_/\\_/
-`;
-// src/utils/plan/planMode.ts
-import { existsSync, mkdirSync, readFileSync, realpathSync } from "fs";
-import { randomBytes } from "crypto";
-import { isAbsolute, join as join2, relative, resolve, parse } from "path";
+var init_sentry = __esm({
+  "src/services/telemetry/sentry.ts"() {
+  }
+});
 // src/utils/system/execFileNoThrow.ts
 import { execFile } from "child_process";
-var MS_IN_SECOND = 1e3;
-var SECONDS_IN_MINUTE = 60;
 function execFileNoThrow(file, args, abortSignal, timeout = 10 * SECONDS_IN_MINUTE * MS_IN_SECOND, preserveOutputOnError = true) {
   return new Promise((resolve3) => {
     try {
@@ -98,799 +60,815 @@ function execFileNoThrow(file, args, abortSignal, timeout = 10 * SECONDS_IN_MINU
     }
   });
 }
+var MS_IN_SECOND, SECONDS_IN_MINUTE;
+var init_execFileNoThrow = __esm({
+  "src/utils/system/execFileNoThrow.ts"() {
+    init_state();
+    init_log();
+    MS_IN_SECOND = 1e3;
+    SECONDS_IN_MINUTE = 60;
+  }
+});
 // src/utils/config/env.ts
 import { memoize } from "lodash-es";
 import { join } from "path";
 import { homedir } from "os";
-function getKodeBaseDir() {
+function getNewcrawBaseDir() {
   return process.env.NEWCRAW_CONFIG_DIR ?? process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), CONFIG_BASE_DIR);
 }
 function getGlobalConfigFilePath() {
-  return process.env.NEWCRAW_CONFIG_DIR || process.env.CLAUDE_CONFIG_DIR ? join(getKodeBaseDir(), "config.json") : join(homedir(), CONFIG_FILE);
+  return join(getNewcrawBaseDir(), "config.json");
 }
 function getMemoryDir() {
-  return join(getKodeBaseDir(), "memory");
-}
-var NEWCRAW_BASE_DIR = getKodeBaseDir();
-var GLOBAL_CONFIG_FILE = getGlobalConfigFilePath();
-var MEMORY_DIR = getMemoryDir();
-var getIsDocker = memoize(async () => {
-  const { code } = await execFileNoThrow("test", ["-f", "/.dockerenv"]);
-  if (code !== 0) {
-    return false;
+  return join(getNewcrawBaseDir(), "memory");
+}
+var NEWCRAW_BASE_DIR, GLOBAL_CONFIG_FILE, MEMORY_DIR, getIsDocker, hasInternetAccess, env;
+var init_env = __esm({
+  "src/utils/config/env.ts"() {
+    init_execFileNoThrow();
+    init_product();
+    NEWCRAW_BASE_DIR = getNewcrawBaseDir();
+    GLOBAL_CONFIG_FILE = getGlobalConfigFilePath();
+    MEMORY_DIR = getMemoryDir();
+    getIsDocker = memoize(async () => {
+      const { code } = await execFileNoThrow("test", ["-f", "/.dockerenv"]);
+      if (code !== 0) {
+        return false;
+      }
+      return process.platform === "linux";
+    });
+    hasInternetAccess = memoize(async () => {
+      const offline = process.env.NEWCRAW_OFFLINE ?? process.env.OFFLINE ?? process.env.NO_NETWORK ?? "";
+      const normalized = String(offline).trim().toLowerCase();
+      if (["1", "true", "yes", "on"].includes(normalized)) return false;
+      return true;
+    });
+    env = {
+      getIsDocker,
+      hasInternetAccess,
+      isCI: Boolean(process.env.CI),
+      platform: process.platform === "win32" ? "windows" : process.platform === "darwin" ? "macos" : "linux",
+      nodeVersion: process.version,
+      terminal: process.env.TERM_PROGRAM
+    };
   }
-  return process.platform === "linux";
-});
-var hasInternetAccess = memoize(async () => {
-  const offline = process.env.NEWCRAW_OFFLINE ?? process.env.OFFLINE ?? process.env.NO_NETWORK ?? "";
-  const normalized = String(offline).trim().toLowerCase();
-  if (["1", "true", "yes", "on"].includes(normalized)) return false;
-  return true;
 });
-var env = {
-  getIsDocker,
-  hasInternetAccess,
-  isCI: Boolean(process.env.CI),
-  platform: process.platform === "win32" ? "windows" : process.platform === "darwin" ? "macos" : "linux",
-  nodeVersion: process.version,
-  terminal: process.env.TERM_PROGRAM
-};
 // src/utils/plan/planSlugWords.ts
-var PLAN_SLUG_ADJECTIVES = [
-  "abundant",
-  "ancient",
-  "bright",
-  "calm",
-  "cheerful",
-  "clever",
-  "cozy",
-  "curious",
-  "dapper",
-  "dazzling",
-  "deep",
-  "delightful",
-  "eager",
-  "elegant",
-  "enchanted",
-  "fancy",
-  "fluffy",
-  "gentle",
-  "gleaming",
-  "golden",
-  "graceful",
-  "happy",
-  "hidden",
-  "humble",
-  "jolly",
-  "joyful",
-  "keen",
-  "kind",
-  "lively",
-  "lovely",
-  "lucky",
-  "luminous",
-  "magical",
-  "majestic",
-  "mellow",
-  "merry",
-  "mighty",
-  "misty",
-  "noble",
-  "peaceful",
-  "playful",
-  "polished",
-  "precious",
-  "proud",
-  "quiet",
-  "quirky",
-  "radiant",
-  "rosy",
-  "serene",
-  "shiny",
-  "silly",
-  "sleepy",
-  "smooth",
-  "snazzy",
-  "snug",
-  "snuggly",
-  "soft",
-  "sparkling",
-  "spicy",
-  "splendid",
-  "sprightly",
-  "starry",
-  "steady",
-  "sunny",
-  "swift",
-  "tender",
-  "tidy",
-  "toasty",
-  "tranquil",
-  "twinkly",
-  "valiant",
-  "vast",
-  "velvet",
-  "vivid",
-  "warm",
-  "whimsical",
-  "wild",
-  "wise",
-  "witty",
-  "wondrous",
-  "zany",
-  "zesty",
-  "zippy",
-  "breezy",
-  "bubbly",
-  "buzzing",
-  "cheeky",
-  "cosmic",
-  "cozy",
-  "crispy",
-  "crystalline",
-  "cuddly",
-  "drifting",
-  "dreamy",
-  "effervescent",
-  "ethereal",
-  "fizzy",
-  "flickering",
-  "floating",
-  "floofy",
-  "fluttering",
-  "foamy",
-  "frolicking",
-  "fuzzy",
-  "giggly",
-  "glimmering",
-  "glistening",
-  "glittery",
-  "glowing",
-  "goofy",
-  "groovy",
-  "harmonic",
-  "hazy",
-  "humming",
-  "iridescent",
-  "jaunty",
-  "jazzy",
-  "jiggly",
-  "melodic",
-  "moonlit",
-  "mossy",
-  "nifty",
-  "peppy",
-  "prancy",
-  "purrfect",
-  "purring",
-  "quizzical",
-  "rippling",
-  "rustling",
-  "shimmering",
-  "shimmying",
-  "snappy",
-  "snoopy",
-  "squishy",
-  "swirling",
-  "ticklish",
-  "tingly",
-  "twinkling",
-  "velvety",
-  "wiggly",
-  "wobbly",
-  "woolly",
-  "zazzy",
-  "abstract",
-  "adaptive",
-  "agile",
-  "async",
-  "atomic",
-  "binary",
-  "cached",
-  "compiled",
-  "composed",
-  "compressed",
-  "concurrent",
-  "cryptic",
-  "curried",
-  "declarative",
-  "delegated",
-  "distributed",
-  "dynamic",
-  "eager",
-  "elegant",
-  "encapsulated",
-  "enumerated",
-  "eventual",
-  "expressive",
-  "federated",
-  "functional",
-  "generic",
-  "greedy",
-  "hashed",
-  "idempotent",
-  "immutable",
-  "imperative",
-  "indexed",
-  "inherited",
-  "iterative",
-  "lazy",
-  "lexical",
-  "linear",
-  "linked",
-  "logical",
-  "memoized",
-  "modular",
-  "mutable",
-  "nested",
-  "optimized",
-  "parallel",
-  "parsed",
-  "partitioned",
-  "piped",
-  "polymorphic",
-  "pure",
-  "reactive",
-  "recursive",
-  "refactored",
-  "reflective",
-  "replicated",
-  "resilient",
-  "robust",
-  "scalable",
-  "sequential",
-  "serialized",
-  "sharded",
-  "sorted",
-  "staged",
-  "stateful",
-  "stateless",
-  "streamed",
-  "structured",
-  "synchronous",
-  "synthetic",
-  "temporal",
-  "transient",
-  "typed",
-  "unified",
-  "validated",
-  "vectorized",
-  "virtual"
-];
-var PLAN_SLUG_VERBS = [
-  "baking",
-  "beaming",
-  "booping",
-  "bouncing",
-  "brewing",
-  "bubbling",
-  "chasing",
-  "churning",
-  "coalescing",
-  "conjuring",
-  "cooking",
-  "crafting",
-  "crunching",
-  "cuddling",
-  "dancing",
-  "dazzling",
-  "discovering",
-  "doodling",
-  "dreaming",
-  "drifting",
-  "enchanting",
-  "exploring",
-  "finding",
-  "floating",
-  "fluttering",
-  "foraging",
-  "forging",
-  "frolicking",
-  "gathering",
-  "giggling",
-  "gliding",
-  "greeting",
-  "growing",
-  "hatching",
-  "herding",
-  "honking",
-  "hopping",
-  "hugging",
-  "humming",
-  "imagining",
-  "inventing",
-  "jingling",
-  "juggling",
-  "jumping",
-  "kindling",
-  "knitting",
-  "launching",
-  "leaping",
-  "mapping",
-  "marinating",
-  "meandering",
-  "mixing",
-  "moseying",
-  "munching",
-  "napping",
-  "nibbling",
-  "noodling",
-  "orbiting",
-  "painting",
-  "percolating",
-  "petting",
-  "plotting",
-  "pondering",
-  "popping",
-  "prancing",
-  "purring",
-  "puzzling",
-  "questing",
-  "riding",
-  "roaming",
-  "rolling",
-  "sauteeing",
-  "scribbling",
-  "seeking",
-  "shimmying",
-  "singing",
-  "skipping",
-  "sleeping",
-  "snacking",
-  "sniffing",
-  "snuggling",
-  "soaring",
-  "sparking",
-  "spinning",
-  "splashing",
-  "sprouting",
-  "squishing",
-  "stargazing",
-  "stirring",
-  "strolling",
-  "swimming",
-  "swinging",
-  "tickling",
-  "tinkering",
-  "toasting",
-  "tumbling",
-  "twirling",
-  "waddling",
-  "wandering",
-  "watching",
-  "weaving",
-  "whistling",
-  "wibbling",
-  "wiggling",
-  "wishing",
-  "wobbling",
-  "wondering",
-  "yawning",
-  "zooming"
-];
-var PLAN_SLUG_NOUNS = [
-  "aurora",
-  "avalanche",
-  "blossom",
-  "breeze",
-  "brook",
-  "bubble",
-  "canyon",
-  "cascade",
-  "cloud",
-  "clover",
-  "comet",
-  "coral",
-  "cosmos",
-  "creek",
-  "crescent",
-  "crystal",
-  "dawn",
-  "dewdrop",
-  "dusk",
-  "eclipse",
-  "ember",
-  "feather",
-  "fern",
-  "firefly",
-  "flame",
-  "flurry",
-  "fog",
-  "forest",
-  "frost",
-  "galaxy",
-  "garden",
-  "glacier",
-  "glade",
-  "grove",
-  "harbor",
-  "horizon",
-  "island",
-  "lagoon",
-  "lake",
-  "leaf",
-  "lightning",
-  "meadow",
-  "meteor",
-  "mist",
-  "moon",
-  "moonbeam",
-  "mountain",
-  "nebula",
-  "nova",
-  "ocean",
-  "orbit",
-  "pebble",
-  "petal",
-  "pine",
-  "planet",
-  "pond",
-  "puddle",
-  "quasar",
-  "rain",
-  "rainbow",
-  "reef",
-  "ripple",
-  "river",
-  "shore",
-  "sky",
-  "snowflake",
-  "spark",
-  "spring",
-  "star",
-  "stardust",
-  "starlight",
-  "storm",
-  "stream",
-  "summit",
-  "sun",
-  "sunbeam",
-  "sunrise",
-  "sunset",
-  "thunder",
-  "tide",
-  "twilight",
-  "valley",
-  "volcano",
-  "waterfall",
-  "wave",
-  "willow",
-  "wind",
-  "alpaca",
-  "axolotl",
-  "badger",
-  "bear",
-  "beaver",
-  "bee",
-  "bird",
-  "bumblebee",
-  "bunny",
-  "cat",
-  "chipmunk",
-  "crab",
-  "crane",
-  "deer",
-  "dolphin",
-  "dove",
-  "dragon",
-  "dragonfly",
-  "duckling",
-  "eagle",
-  "elephant",
-  "falcon",
-  "finch",
-  "flamingo",
-  "fox",
-  "frog",
-  "giraffe",
-  "goose",
-  "hamster",
-  "hare",
-  "hedgehog",
-  "hippo",
-  "hummingbird",
-  "jellyfish",
-  "kitten",
-  "koala",
-  "ladybug",
-  "lark",
-  "lemur",
-  "llama",
-  "lobster",
-  "lynx",
-  "manatee",
-  "meerkat",
-  "moth",
-  "narwhal",
-  "newt",
-  "octopus",
-  "otter",
-  "owl",
-  "panda",
-  "parrot",
-  "peacock",
-  "pelican",
-  "penguin",
-  "phoenix",
-  "piglet",
-  "platypus",
-  "pony",
-  "porcupine",
-  "puffin",
-  "puppy",
-  "quail",
-  "quokka",
-  "rabbit",
-  "raccoon",
-  "raven",
-  "robin",
-  "salamander",
-  "seahorse",
-  "seal",
-  "sloth",
-  "snail",
-  "sparrow",
-  "sphinx",
-  "squid",
-  "squirrel",
-  "starfish",
-  "swan",
-  "tiger",
-  "toucan",
-  "turtle",
-  "unicorn",
-  "walrus",
-  "whale",
-  "wolf",
-  "wombat",
-  "wren",
-  "yeti",
-  "zebra",
-  "acorn",
-  "anchor",
-  "balloon",
-  "beacon",
-  "biscuit",
-  "blanket",
-  "bonbon",
-  "book",
-  "boot",
-  "cake",
-  "candle",
-  "candy",
-  "castle",
-  "charm",
-  "clock",
-  "cocoa",
-  "cookie",
-  "crayon",
-  "crown",
-  "cupcake",
-  "donut",
-  "dream",
-  "fairy",
-  "fiddle",
-  "flask",
-  "flute",
-  "fountain",
-  "gadget",
-  "gem",
-  "gizmo",
-  "globe",
-  "goblet",
-  "hammock",
-  "harp",
-  "haven",
-  "hearth",
-  "honey",
-  "journal",
-  "kazoo",
-  "kettle",
-  "key",
-  "kite",
-  "lantern",
-  "lemon",
-  "lighthouse",
-  "locket",
-  "lollipop",
-  "mango",
-  "map",
-  "marble",
-  "marshmallow",
-  "melody",
-  "mitten",
-  "mochi",
-  "muffin",
-  "music",
-  "nest",
-  "noodle",
-  "oasis",
-  "origami",
-  "pancake",
-  "parasol",
-  "peach",
-  "pearl",
-  "pebble",
-  "pie",
-  "pillow",
-  "pinwheel",
-  "pixel",
-  "pizza",
-  "plum",
-  "popcorn",
-  "pretzel",
-  "prism",
-  "pudding",
-  "pumpkin",
-  "puzzle",
-  "quiche",
-  "quill",
-  "quilt",
-  "riddle",
-  "rocket",
-  "rose",
-  "scone",
-  "scroll",
-  "shell",
-  "sketch",
-  "snowglobe",
-  "sonnet",
-  "sparkle",
-  "spindle",
-  "sprout",
-  "sundae",
-  "swing",
-  "taco",
-  "teacup",
-  "teapot",
-  "thimble",
-  "toast",
-  "token",
-  "tome",
-  "tower",
-  "treasure",
-  "treehouse",
-  "trinket",
-  "truffle",
-  "tulip",
-  "umbrella",
-  "waffle",
-  "wand",
-  "whisper",
-  "whistle",
-  "widget",
-  "wreath",
-  "zephyr",
-  "abelson",
-  "adleman",
-  "aho",
-  "allen",
-  "babbage",
-  "bachman",
-  "backus",
-  "barto",
-  "bengio",
-  "bentley",
-  "blum",
-  "boole",
-  "brooks",
-  "catmull",
-  "cerf",
-  "cherny",
-  "church",
-  "clarke",
-  "cocke",
-  "codd",
-  "conway",
-  "cook",
-  "corbato",
-  "cray",
-  "curry",
-  "dahl",
-  "diffie",
-  "dijkstra",
-  "dongarra",
-  "eich",
-  "emerson",
-  "engelbart",
-  "feigenbaum",
-  "floyd",
-  "gosling",
-  "graham",
-  "gray",
-  "hamming",
-  "hanrahan",
-  "hartmanis",
-  "hejlsberg",
-  "hellman",
-  "hennessy",
-  "hickey",
-  "hinton",
-  "hoare",
-  "hollerith",
-  "hopcroft",
-  "hopper",
-  "iverson",
-  "kahan",
-  "kahn",
-  "karp",
-  "kay",
-  "kernighan",
-  "knuth",
-  "kurzweil",
-  "lamport",
-  "lampson",
-  "lecun",
-  "lerdorf",
-  "liskov",
-  "lovelace",
-  "matsumoto",
-  "mccarthy",
-  "metcalfe",
-  "micali",
-  "milner",
-  "minsky",
-  "moler",
-  "moore",
-  "naur",
-  "neumann",
-  "newell",
-  "nygaard",
-  "papert",
-  "parnas",
-  "pascal",
-  "patterson",
-  "pearl",
-  "perlis",
-  "pike",
-  "pnueli",
-  "rabin",
-  "reddy",
-  "ritchie",
-  "rivest",
-  "rossum",
-  "russell",
-  "scott",
-  "sedgewick",
-  "shamir",
-  "shannon",
-  "sifakis",
-  "simon",
-  "stallman",
-  "stearns",
-  "steele",
-  "stonebraker",
-  "stroustrup",
-  "sutherland",
-  "sutton",
-  "tarjan",
-  "thacker",
-  "thompson",
-  "torvalds",
-  "turing",
-  "ullman",
-  "valiant",
-  "wadler",
-  "wall",
-  "wigderson",
-  "wilkes",
-  "wilkinson",
-  "wirth",
-  "wozniak",
-  "yao"
-];
+var PLAN_SLUG_ADJECTIVES, PLAN_SLUG_VERBS, PLAN_SLUG_NOUNS;
+var init_planSlugWords = __esm({
+  "src/utils/plan/planSlugWords.ts"() {
+    PLAN_SLUG_ADJECTIVES = [
+      "abundant",
+      "ancient",
+      "bright",
+      "calm",
+      "cheerful",
+      "clever",
+      "cozy",
+      "curious",
+      "dapper",
+      "dazzling",
+      "deep",
+      "delightful",
+      "eager",
+      "elegant",
+      "enchanted",
+      "fancy",
+      "fluffy",
+      "gentle",
+      "gleaming",
+      "golden",
+      "graceful",
+      "happy",
+      "hidden",
+      "humble",
+      "jolly",
+      "joyful",
+      "keen",
+      "kind",
+      "lively",
+      "lovely",
+      "lucky",
+      "luminous",
+      "magical",
+      "majestic",
+      "mellow",
+      "merry",
+      "mighty",
+      "misty",
+      "noble",
+      "peaceful",
+      "playful",
+      "polished",
+      "precious",
+      "proud",
+      "quiet",
+      "quirky",
+      "radiant",
+      "rosy",
+      "serene",
+      "shiny",
+      "silly",
+      "sleepy",
+      "smooth",
+      "snazzy",
+      "snug",
+      "snuggly",
+      "soft",
+      "sparkling",
+      "spicy",
+      "splendid",
+      "sprightly",
+      "starry",
+      "steady",
+      "sunny",
+      "swift",
+      "tender",
+      "tidy",
+      "toasty",
+      "tranquil",
+      "twinkly",
+      "valiant",
+      "vast",
+      "velvet",
+      "vivid",
+      "warm",
+      "whimsical",
+      "wild",
+      "wise",
+      "witty",
+      "wondrous",
+      "zany",
+      "zesty",
+      "zippy",
+      "breezy",
+      "bubbly",
+      "buzzing",
+      "cheeky",
+      "cosmic",
+      "cozy",
+      "crispy",
+      "crystalline",
+      "cuddly",
+      "drifting",
+      "dreamy",
+      "effervescent",
+      "ethereal",
+      "fizzy",
+      "flickering",
+      "floating",
+      "floofy",
+      "fluttering",
+      "foamy",
+      "frolicking",
+      "fuzzy",
+      "giggly",
+      "glimmering",
+      "glistening",
+      "glittery",
+      "glowing",
+      "goofy",
+      "groovy",
+      "harmonic",
+      "hazy",
+      "humming",
+      "iridescent",
+      "jaunty",
+      "jazzy",
+      "jiggly",
+      "melodic",
+      "moonlit",
+      "mossy",
+      "nifty",
+      "peppy",
+      "prancy",
+      "purrfect",
+      "purring",
+      "quizzical",
+      "rippling",
+      "rustling",
+      "shimmering",
+      "shimmying",
+      "snappy",
+      "snoopy",
+      "squishy",
+      "swirling",
+      "ticklish",
+      "tingly",
+      "twinkling",
+      "velvety",
+      "wiggly",
+      "wobbly",
+      "woolly",
+      "zazzy",
+      "abstract",
+      "adaptive",
+      "agile",
+      "async",
+      "atomic",
+      "binary",
+      "cached",
+      "compiled",
+      "composed",
+      "compressed",
+      "concurrent",
+      "cryptic",
+      "curried",
+      "declarative",
+      "delegated",
+      "distributed",
+      "dynamic",
+      "eager",
+      "elegant",
+      "encapsulated",
+      "enumerated",
+      "eventual",
+      "expressive",
+      "federated",
+      "functional",
+      "generic",
+      "greedy",
+      "hashed",
+      "idempotent",
+      "immutable",
+      "imperative",
+      "indexed",
+      "inherited",
+      "iterative",
+      "lazy",
+      "lexical",
+      "linear",
+      "linked",
+      "logical",
+      "memoized",
+      "modular",
+      "mutable",
+      "nested",
+      "optimized",
+      "parallel",
+      "parsed",
+      "partitioned",
+      "piped",
+      "polymorphic",
+      "pure",
+      "reactive",
+      "recursive",
+      "refactored",
+      "reflective",
+      "replicated",
+      "resilient",
+      "robust",
+      "scalable",
+      "sequential",
+      "serialized",
+      "sharded",
+      "sorted",
+      "staged",
+      "stateful",
+      "stateless",
+      "streamed",
+      "structured",
+      "synchronous",
+      "synthetic",
+      "temporal",
+      "transient",
+      "typed",
+      "unified",
+      "validated",
+      "vectorized",
+      "virtual"
+    ];
+    PLAN_SLUG_VERBS = [
+      "baking",
+      "beaming",
+      "booping",
+      "bouncing",
+      "brewing",
+      "bubbling",
+      "chasing",
+      "churning",
+      "coalescing",
+      "conjuring",
+      "cooking",
+      "crafting",
+      "crunching",
+      "cuddling",
+      "dancing",
+      "dazzling",
+      "discovering",
+      "doodling",
+      "dreaming",
+      "drifting",
+      "enchanting",
+      "exploring",
+      "finding",
+      "floating",
+      "fluttering",
+      "foraging",
+      "forging",
+      "frolicking",
+      "gathering",
+      "giggling",
+      "gliding",
+      "greeting",
+      "growing",
+      "hatching",
+      "herding",
+      "honking",
+      "hopping",
+      "hugging",
+      "humming",
+      "imagining",
+      "inventing",
+      "jingling",
+      "juggling",
+      "jumping",
+      "kindling",
+      "knitting",
+      "launching",
+      "leaping",
+      "mapping",
+      "marinating",
+      "meandering",
+      "mixing",
+      "moseying",
+      "munching",
+      "napping",
+      "nibbling",
+      "noodling",
+      "orbiting",
+      "painting",
+      "percolating",
+      "petting",
+      "plotting",
+      "pondering",
+      "popping",
+      "prancing",
+      "purring",
+      "puzzling",
+      "questing",
+      "riding",
+      "roaming",
+      "rolling",
+      "sauteeing",
+      "scribbling",
+      "seeking",
+      "shimmying",
+      "singing",
+      "skipping",
+      "sleeping",
+      "snacking",
+      "sniffing",
+      "snuggling",
+      "soaring",
+      "sparking",
+      "spinning",
+      "splashing",
+      "sprouting",
+      "squishing",
+      "stargazing",
+      "stirring",
+      "strolling",
+      "swimming",
+      "swinging",
+      "tickling",
+      "tinkering",
+      "toasting",
+      "tumbling",
+      "twirling",
+      "waddling",
+      "wandering",
+      "watching",
+      "weaving",
+      "whistling",
+      "wibbling",
+      "wiggling",
+      "wishing",
+      "wobbling",
+      "wondering",
+      "yawning",
+      "zooming"
+    ];
+    PLAN_SLUG_NOUNS = [
+      "aurora",
+      "avalanche",
+      "blossom",
+      "breeze",
+      "brook",
+      "bubble",
+      "canyon",
+      "cascade",
+      "cloud",
+      "clover",
+      "comet",
+      "coral",
+      "cosmos",
+      "creek",
+      "crescent",
+      "crystal",
+      "dawn",
+      "dewdrop",
+      "dusk",
+      "eclipse",
+      "ember",
+      "feather",
+      "fern",
+      "firefly",
+      "flame",
+      "flurry",
+      "fog",
+      "forest",
+      "frost",
+      "galaxy",
+      "garden",
+      "glacier",
+      "glade",
+      "grove",
+      "harbor",
+      "horizon",
+      "island",
+      "lagoon",
+      "lake",
+      "leaf",
+      "lightning",
+      "meadow",
+      "meteor",
+      "mist",
+      "moon",
+      "moonbeam",
+      "mountain",
+      "nebula",
+      "nova",
+      "ocean",
+      "orbit",
+      "pebble",
+      "petal",
+      "pine",
+      "planet",
+      "pond",
+      "puddle",
+      "quasar",
+      "rain",
+      "rainbow",
+      "reef",
+      "ripple",
+      "river",
+      "shore",
+      "sky",
+      "snowflake",
+      "spark",
+      "spring",
+      "star",
+      "stardust",
+      "starlight",
+      "storm",
+      "stream",
+      "summit",
+      "sun",
+      "sunbeam",
+      "sunrise",
+      "sunset",
+      "thunder",
+      "tide",
+      "twilight",
+      "valley",
+      "volcano",
+      "waterfall",
+      "wave",
+      "willow",
+      "wind",
+      "alpaca",
+      "axolotl",
+      "badger",
+      "bear",
+      "beaver",
+      "bee",
+      "bird",
+      "bumblebee",
+      "bunny",
+      "cat",
+      "chipmunk",
+      "crab",
+      "crane",
+      "deer",
+      "dolphin",
+      "dove",
+      "dragon",
+      "dragonfly",
+      "duckling",
+      "eagle",
+      "elephant",
+      "falcon",
+      "finch",
+      "flamingo",
+      "fox",
+      "frog",
+      "giraffe",
+      "goose",
+      "hamster",
+      "hare",
+      "hedgehog",
+      "hippo",
+      "hummingbird",
+      "jellyfish",
+      "kitten",
+      "koala",
+      "ladybug",
+      "lark",
+      "lemur",
+      "llama",
+      "lobster",
+      "lynx",
+      "manatee",
+      "meerkat",
+      "moth",
+      "narwhal",
+      "newt",
+      "octopus",
+      "otter",
+      "owl",
+      "panda",
+      "parrot",
+      "peacock",
+      "pelican",
+      "penguin",
+      "phoenix",
+      "piglet",
+      "platypus",
+      "pony",
+      "porcupine",
+      "puffin",
+      "puppy",
+      "quail",
+      "quokka",
+      "rabbit",
+      "raccoon",
+      "raven",
+      "robin",
+      "salamander",
+      "seahorse",
+      "seal",
+      "sloth",
+      "snail",
+      "sparrow",
+      "sphinx",
+      "squid",
+      "squirrel",
+      "starfish",
+      "swan",
+      "tiger",
+      "toucan",
+      "turtle",
+      "unicorn",
+      "walrus",
+      "whale",
+      "wolf",
+      "wombat",
+      "wren",
+      "yeti",
+      "zebra",
+      "acorn",
+      "anchor",
+      "balloon",
+      "beacon",
+      "biscuit",
+      "blanket",
+      "bonbon",
+      "book",
+      "boot",
+      "cake",
+      "candle",
+      "candy",
+      "castle",
+      "charm",
+      "clock",
+      "cocoa",
+      "cookie",
+      "crayon",
+      "crown",
+      "cupcake",
+      "donut",
+      "dream",
+      "fairy",
+      "fiddle",
+      "flask",
+      "flute",
+      "fountain",
+      "gadget",
+      "gem",
+      "gizmo",
+      "globe",
+      "goblet",
+      "hammock",
+      "harp",
+      "haven",
+      "hearth",
+      "honey",
+      "journal",
+      "kazoo",
+      "kettle",
+      "key",
+      "kite",
+      "lantern",
+      "lemon",
+      "lighthouse",
+      "locket",
+      "lollipop",
+      "mango",
+      "map",
+      "marble",
+      "marshmallow",
+      "melody",
+      "mitten",
+      "mochi",
+      "muffin",
+      "music",
+      "nest",
+      "noodle",
+      "oasis",
+      "origami",
+      "pancake",
+      "parasol",
+      "peach",
+      "pearl",
+      "pebble",
+      "pie",
+      "pillow",
+      "pinwheel",
+      "pixel",
+      "pizza",
+      "plum",
+      "popcorn",
+      "pretzel",
+      "prism",
+      "pudding",
+      "pumpkin",
+      "puzzle",
+      "quiche",
+      "quill",
+      "quilt",
+      "riddle",
+      "rocket",
+      "rose",
+      "scone",
+      "scroll",
+      "shell",
+      "sketch",
+      "snowglobe",
+      "sonnet",
+      "sparkle",
+      "spindle",
+      "sprout",
+      "sundae",
+      "swing",
+      "taco",
+      "teacup",
+      "teapot",
+      "thimble",
+      "toast",
+      "token",
+      "tome",
+      "tower",
+      "treasure",
+      "treehouse",
+      "trinket",
+      "truffle",
+      "tulip",
+      "umbrella",
+      "waffle",
+      "wand",
+      "whisper",
+      "whistle",
+      "widget",
+      "wreath",
+      "zephyr",
+      "abelson",
+      "adleman",
+      "aho",
+      "allen",
+      "babbage",
+      "bachman",
+      "backus",
+      "barto",
+      "bengio",
+      "bentley",
+      "blum",
+      "boole",
+      "brooks",
+      "catmull",
+      "cerf",
+      "cherny",
+      "church",
+      "clarke",
+      "cocke",
+      "codd",
+      "conway",
+      "cook",
+      "corbato",
+      "cray",
+      "curry",
+      "dahl",
+      "diffie",
+      "dijkstra",
+      "dongarra",
+      "eich",
+      "emerson",
+      "engelbart",
+      "feigenbaum",
+      "floyd",
+      "gosling",
+      "graham",
+      "gray",
+      "hamming",
+      "hanrahan",
+      "hartmanis",
+      "hejlsberg",
+      "hellman",
+      "hennessy",
+      "hickey",
+      "hinton",
+      "hoare",
+      "hollerith",
+      "hopcroft",
+      "hopper",
+      "iverson",
+      "kahan",
+      "kahn",
+      "karp",
+      "kay",
+      "kernighan",
+      "knuth",
+      "kurzweil",
+      "lamport",
+      "lampson",
+      "lecun",
+      "lerdorf",
+      "liskov",
+      "lovelace",
+      "matsumoto",
+      "mccarthy",
+      "metcalfe",
+      "micali",
+      "milner",
+      "minsky",
+      "moler",
+      "moore",
+      "naur",
+      "neumann",
+      "newell",
+      "nygaard",
+      "papert",
+      "parnas",
+      "pascal",
+      "patterson",
+      "pearl",
+      "perlis",
+      "pike",
+      "pnueli",
+      "rabin",
+      "reddy",
+      "ritchie",
+      "rivest",
+      "rossum",
+      "russell",
+      "scott",
+      "sedgewick",
+      "shamir",
+      "shannon",
+      "sifakis",
+      "simon",
+      "stallman",
+      "stearns",
+      "steele",
+      "stonebraker",
+      "stroustrup",
+      "sutherland",
+      "sutton",
+      "tarjan",
+      "thacker",
+      "thompson",
+      "torvalds",
+      "turing",
+      "ullman",
+      "valiant",
+      "wadler",
+      "wall",
+      "wigderson",
+      "wilkes",
+      "wilkinson",
+      "wirth",
+      "wozniak",
+      "yao"
+    ];
+  }
+});
 // src/utils/plan/planMode.ts
-var DEFAULT_CONVERSATION_KEY = "default";
-var MAX_SLUG_ATTEMPTS = 10;
-var TURNS_BETWEEN_ATTACHMENTS = 5;
-var planModeEnabledByConversationKey = /* @__PURE__ */ new Map();
-var planSlugCache = /* @__PURE__ */ new Map();
-var planModeFlagsByConversationKey = /* @__PURE__ */ new Map();
-var planModeAttachmentStateByAgentKey = /* @__PURE__ */ new Map();
-var activePlanConversationKey = null;
+import { existsSync, mkdirSync, readFileSync, realpathSync } from "fs";
+import { randomBytes } from "crypto";
+import { isAbsolute, join as join2, relative, resolve, parse } from "path";
 function getConversationKey(context) {
   const messageLogName = context?.options?.messageLogName ?? DEFAULT_CONVERSATION_KEY;
   const forkNumber = context?.options?.forkNumber ?? 0;
@@ -1179,7 +1157,7 @@ function hydratePlanSlugFromMessages(messages, context) {
   return false;
 }
 function getPlanDirectory() {
-  const dir = join2(getKodeBaseDir(), "plans");
+  const dir = join2(getNewcrawBaseDir(), "plans");
   if (!existsSync(dir)) {
     mkdirSync(dir, { recursive: true });
   }
@@ -1217,11 +1195,36 @@ function readPlanFile(agentId, conversationKey) {
     planFilePath
   };
 }
+var DEFAULT_CONVERSATION_KEY, MAX_SLUG_ATTEMPTS, TURNS_BETWEEN_ATTACHMENTS, planModeEnabledByConversationKey, planSlugCache, planModeFlagsByConversationKey, planModeAttachmentStateByAgentKey, activePlanConversationKey;
+var init_planMode = __esm({
+  "src/utils/plan/planMode.ts"() {
+    init_env();
+    init_planSlugWords();
+    DEFAULT_CONVERSATION_KEY = "default";
+    MAX_SLUG_ATTEMPTS = 10;
+    TURNS_BETWEEN_ATTACHMENTS = 5;
+    planModeEnabledByConversationKey = /* @__PURE__ */ new Map();
+    planSlugCache = /* @__PURE__ */ new Map();
+    planModeFlagsByConversationKey = /* @__PURE__ */ new Map();
+    planModeAttachmentStateByAgentKey = /* @__PURE__ */ new Map();
+    activePlanConversationKey = null;
+  }
+});
 // src/utils/log/index.ts
-var IN_MEMORY_ERROR_LOG = [];
-var MAX_IN_MEMORY_ERRORS = 100;
-var PERMISSION_ERROR_CODES = /* @__PURE__ */ new Set(["EACCES", "EPERM", "EROFS"]);
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  writeFileSync,
+  readFileSync as readFileSync2,
+  readdirSync,
+  statSync,
+  copyFileSync,
+  promises as fsPromises
+} from "fs";
+import { dirname, join as join3 } from "path";
+import { randomUUID } from "crypto";
+import envPaths from "env-paths";
 function isPermissionError(error) {
   return typeof error === "object" && error !== null && "code" in error && PERMISSION_ERROR_CODES.has(error.code ?? "");
 }
@@ -1248,8 +1251,6 @@ function safeWriteFile(path, data, encoding = "utf8") {
     throw error;
   }
 }
-var SESSION_ID = randomUUID();
-var paths = envPaths(PRODUCT_COMMAND);
 function getProjectDir(cwd2) {
   return cwd2.replace(/[^a-zA-Z0-9]/g, "-");
 }
@@ -1257,30 +1258,11 @@ function getLegacyCacheRoot() {
   return process.env.NEWCRAW_LEGACY_CACHE_ROOT ?? paths.cache;
 }
 function getNewLogRoot() {
-  return process.env.NEWCRAW_LOG_ROOT ?? getKodeBaseDir();
-}
-var CACHE_PATHS = {
-  errors: () => join3(getNewLogRoot(), getProjectDir(process.cwd()), "errors"),
-  messages: () => join3(getNewLogRoot(), getProjectDir(process.cwd()), "messages"),
-  mcpLogs: (serverName) => join3(
-    getLegacyCacheRoot(),
-    getProjectDir(process.cwd()),
-    `mcp-logs-${serverName}`
-  )
-};
-var LEGACY_CACHE_PATHS = {
-  errors: () => join3(getLegacyCacheRoot(), getProjectDir(process.cwd()), "errors"),
-  messages: () => join3(getLegacyCacheRoot(), getProjectDir(process.cwd()), "messages"),
-  mcpLogs: (serverName) => join3(
-    getLegacyCacheRoot(),
-    getProjectDir(process.cwd()),
-    `mcp-logs-${serverName}`
-  )
-};
+  return process.env.NEWCRAW_LOG_ROOT ?? getNewcrawBaseDir();
+}
 function dateToFilename(date) {
   return date.toISOString().replace(/[:.]/g, "-");
 }
-var DATE = dateToFilename(/* @__PURE__ */ new Date());
 function getErrorsPath() {
   return join3(CACHE_PATHS.errors(), DATE + ".txt");
 }
@@ -1290,8 +1272,6 @@ function getMessagesPath(messageLogName, forkNumber, sidechainNumber) {
     `${messageLogName}${forkNumber > 0 ? `-${forkNumber}` : ""}${sidechainNumber > 0 ? `-sidechain-${sidechainNumber}` : ""}.json`
   );
 }
-var MIGRATION_MESSAGE_LOG_LIMIT = 50;
-var didMigrateMessageLogs = false;
 function migrateLegacyMessageLogsIfNeeded() {
   if (didMigrateMessageLogs) return;
   didMigrateMessageLogs = true;
@@ -1567,6 +1547,42 @@ function logMCPError(serverName, error) {
   } catch {
   }
 }
+var IN_MEMORY_ERROR_LOG, MAX_IN_MEMORY_ERRORS, PERMISSION_ERROR_CODES, SESSION_ID, paths, CACHE_PATHS, LEGACY_CACHE_PATHS, DATE, MIGRATION_MESSAGE_LOG_LIMIT, didMigrateMessageLogs;
+var init_log = __esm({
+  "src/utils/log/index.ts"() {
+    init_sentry();
+    init_macros();
+    init_product();
+    init_planMode();
+    init_env();
+    IN_MEMORY_ERROR_LOG = [];
+    MAX_IN_MEMORY_ERRORS = 100;
+    PERMISSION_ERROR_CODES = /* @__PURE__ */ new Set(["EACCES", "EPERM", "EROFS"]);
+    SESSION_ID = randomUUID();
+    paths = envPaths(PRODUCT_COMMAND);
+    CACHE_PATHS = {
+      errors: () => join3(getNewLogRoot(), getProjectDir(process.cwd()), "errors"),
+      messages: () => join3(getNewLogRoot(), getProjectDir(process.cwd()), "messages"),
+      mcpLogs: (serverName) => join3(
+        getLegacyCacheRoot(),
+        getProjectDir(process.cwd()),
+        `mcp-logs-${serverName}`
+      )
+    };
+    LEGACY_CACHE_PATHS = {
+      errors: () => join3(getLegacyCacheRoot(), getProjectDir(process.cwd()), "errors"),
+      messages: () => join3(getLegacyCacheRoot(), getProjectDir(process.cwd()), "messages"),
+      mcpLogs: (serverName) => join3(
+        getLegacyCacheRoot(),
+        getProjectDir(process.cwd()),
+        `mcp-logs-${serverName}`
+      )
+    };
+    DATE = dateToFilename(/* @__PURE__ */ new Date());
+    MIGRATION_MESSAGE_LOG_LIMIT = 50;
+    didMigrateMessageLogs = false;
+  }
+});
 // src/utils/log/taskOutputStore.ts
 import {
@@ -1581,9 +1597,8 @@ import { dirname as dirname2, join as join4 } from "path";
 function getProjectDir2(cwd2) {
   return cwd2.replace(/[^a-zA-Z0-9]/g, "-");
 }
-var PROJECT_ROOT = process.cwd();
 function getTaskOutputsDir() {
-  return join4(getKodeBaseDir(), getProjectDir2(PROJECT_ROOT), "tasks");
+  return join4(getNewcrawBaseDir(), getProjectDir2(PROJECT_ROOT), "tasks");
 }
 function getTaskOutputFilePath(taskId) {
   return join4(getTaskOutputsDir(), `${taskId}.output`);
@@ -1619,8 +1634,21 @@ function readTaskOutput(taskId) {
     return "";
   }
 }
+var PROJECT_ROOT;
+var init_taskOutputStore = __esm({
+  "src/utils/log/taskOutputStore.ts"() {
+    init_env();
+    PROJECT_ROOT = process.cwd();
+  }
+});
 // src/utils/bun/shell.ts
+import { spawn } from "child_process";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, realpathSync as realpathSync2, statSync as statSync3 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import { homedir as homedir2 } from "os";
+import { basename, dirname as dirname3, isAbsolute as isAbsolute2, join as join5, resolve as resolve2 } from "path";
+import which from "which";
 function whichSync(bin) {
   try {
     return which.sync(bin, { nothrow: true }) ?? null;
@@ -2098,393 +2126,521 @@ function renderBashNotification(notification) {
     "</bash-notification>"
   ].join("\n");
 }
-var BunShell = class _BunShell {
-  cwd;
-  isAlive = true;
-  currentProcess = null;
-  abortController = null;
-  backgroundProcesses = /* @__PURE__ */ new Map();
-  constructor(cwd2) {
-    this.cwd = cwd2;
-  }
-  static instance = null;
-  static restart() {
-    if (_BunShell.instance) {
-      _BunShell.instance.close();
-      _BunShell.instance = null;
-    }
-  }
-  static getInstance() {
-    if (!_BunShell.instance || !_BunShell.instance.isAlive) {
-      _BunShell.instance = new _BunShell(process.cwd());
-    }
-    return _BunShell.instance;
-  }
-  static getShellCmdForPlatform(platform, command, _env = process.env) {
-    if (platform === "win32") {
-      return [resolvePowerShellPath(), "-NoProfile", "-NonInteractive", "-Command", command];
-    }
-    const sh = existsSync4("/bin/sh") ? "/bin/sh" : "sh";
-    return [sh, "-c", command];
-  }
-  getShellCmd(command) {
-    return _BunShell.getShellCmdForPlatform(
-      process.platform,
-      command,
-      process.env
-    );
-  }
-  buildSandboxCmd(command, sandbox) {
-    if (!sandbox.enabled) return null;
-    const platform = sandbox.__platformOverride ?? process.platform;
-    const needsNetworkRestriction = sandbox.needsNetworkRestriction !== void 0 ? sandbox.needsNetworkRestriction : sandbox.allowNetwork === true ? false : true;
-    const writeConfig = sandbox.writeConfig ?? (sandbox.writableRoots && sandbox.writableRoots.length > 0 ? { allowOnly: sandbox.writableRoots.filter(Boolean) } : void 0);
-    const readConfig = sandbox.readConfig;
-    const hasReadRestrictions = (readConfig?.denyOnly?.length ?? 0) > 0;
-    const hasWriteRestrictions = writeConfig !== void 0;
-    const hasNetworkRestrictions = needsNetworkRestriction === true;
-    if (!hasReadRestrictions && !hasWriteRestrictions && !hasNetworkRestrictions) {
-      return null;
-    }
-    const binShell = sandbox.binShell ?? (whichSync("bash") ? "bash" : "sh");
-    const binShellPath = whichOrSelf(binShell);
-    const cwd2 = sandbox.chdir || this.cwd;
-    if (platform === "linux") {
-      const bwrapPath = sandbox.__bwrapPathOverride !== void 0 ? sandbox.__bwrapPathOverride : whichSync("bwrap") ?? whichSync("bubblewrap");
-      if (!bwrapPath) {
-        return null;
+var BunShell;
+var init_shell = __esm({
+  "src/utils/bun/shell.ts"() {
+    init_log();
+    init_taskOutputStore();
+    BunShell = class _BunShell {
+      cwd;
+      isAlive = true;
+      currentProcess = null;
+      abortController = null;
+      backgroundProcesses = /* @__PURE__ */ new Map();
+      constructor(cwd2) {
+        this.cwd = cwd2;
       }
-      try {
-        mkdirSync4("/tmp/newcraw", { recursive: true });
-      } catch {
-      }
-      const cmd = buildLinuxBwrapCommand({
-        bwrapPath,
-        command,
-        needsNetworkRestriction,
-        readConfig,
-        writeConfig,
-        enableWeakerNestedSandbox: sandbox.enableWeakerNestedSandbox,
-        binShellPath,
-        cwd: cwd2
-      });
-      return { cmd };
-    }
-    if (platform === "darwin") {
-      const sandboxExecPath = sandbox.__sandboxExecPathOverride !== void 0 ? sandbox.__sandboxExecPathOverride : existsSync4("/usr/bin/sandbox-exec") ? "/usr/bin/sandbox-exec" : whichSync("sandbox-exec");
-      if (!sandboxExecPath) {
-        return null;
-      }
-      try {
-        mkdirSync4("/tmp/newcraw", { recursive: true });
-      } catch {
-      }
-      try {
-        mkdirSync4("/private/tmp/newcraw", { recursive: true });
-      } catch {
-      }
-      return {
-        cmd: buildMacosSandboxExecCommand({
-          sandboxExecPath,
-          binShellPath,
-          command,
-          needsNetworkRestriction,
-          httpProxyPort: sandbox.httpProxyPort,
-          socksProxyPort: sandbox.socksProxyPort,
-          allowUnixSockets: sandbox.allowUnixSockets,
-          allowAllUnixSockets: sandbox.allowAllUnixSockets,
-          allowLocalBinding: sandbox.allowLocalBinding,
-          readConfig,
-          writeConfig
-        })
-      };
-    }
-    return null;
-  }
-  isSandboxInitFailure(stderr) {
-    const s = stderr.toLowerCase();
-    return s.includes("bwrap:") || s.includes("bubblewrap") || s.includes("namespace") && s.includes("failed");
-  }
-  startStreamReader(stream, append) {
-    if (!stream) return;
-    try {
-      ;
-      stream.setEncoding?.("utf8");
-    } catch {
-    }
-    stream.on("data", (chunk) => {
-      append(
-        typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk)
-      );
-    });
-    stream.on("error", (err) => {
-      logError(`Stream read error: ${err}`);
-    });
-  }
-  createCancellableTextCollector(stream, options) {
-    let text = "";
-    const collectText = options?.collectText !== false;
-    if (!stream) {
-      return {
-        getText: () => text,
-        done: Promise.resolve(),
-        cancel: async () => {
+      static instance = null;
+      static restart() {
+        if (_BunShell.instance) {
+          _BunShell.instance.close();
+          _BunShell.instance = null;
         }
-      };
-    }
-    let cancelled = false;
-    let resolveDone = null;
-    const done = new Promise((resolve3) => {
-      resolveDone = resolve3;
-    });
-    const finish = () => {
-      if (!resolveDone) return;
-      resolveDone();
-      resolveDone = null;
-    };
-    const onData = (chunk) => {
-      if (cancelled) return;
-      const s = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
-      if (collectText) text += s;
-      options?.onChunk?.(s);
-    };
-    const onEnd = () => {
-      cleanup();
-      finish();
-    };
-    const onClose = () => {
-      cleanup();
-      finish();
-    };
-    const cleanup = () => {
-      stream.off("data", onData);
-      stream.off("end", onEnd);
-      stream.off("close", onClose);
-      stream.off("error", onError);
-    };
-    const onError = (err) => {
-      if (!cancelled) {
-        logError(`Stream read error: ${err}`);
-      }
-      cleanup();
-      finish();
-    };
-    try {
-      ;
-      stream.setEncoding?.("utf8");
-    } catch {
-    }
-    stream.on("data", onData);
-    stream.once("end", onEnd);
-    stream.once("close", onClose);
-    stream.once("error", onError);
-    return {
-      getText: () => text,
-      done,
-      cancel: async () => {
-        if (cancelled) return;
-        cancelled = true;
-        cleanup();
-        finish();
-      }
-    };
-  }
-  static makeBackgroundTaskId() {
-    return `b${randomUUID2().replace(/-/g, "").slice(0, 6)}`;
-  }
-  execPromotable(command, abortSignal, timeout, options) {
-    const DEFAULT_TIMEOUT = 12e4;
-    const commandTimeout = timeout ?? DEFAULT_TIMEOUT;
-    const startedAt = Date.now();
-    const sandbox = options?.sandbox;
-    const shouldAttemptSandbox = sandbox?.enabled === true;
-    const executionCwd = shouldAttemptSandbox && sandbox?.chdir ? sandbox.chdir : this.cwd;
-    if (abortSignal?.aborted) {
-      return {
-        get status() {
-          return "killed";
-        },
-        background: () => null,
-        kill: () => {
-        },
-        result: Promise.resolve({
-          stdout: "",
-          stderr: "Command aborted before execution",
-          code: 145,
-          interrupted: true
-        })
-      };
-    }
-    const sandboxCmd = shouldAttemptSandbox ? this.buildSandboxCmd(command, sandbox) : null;
-    if (shouldAttemptSandbox && sandbox?.require && !sandboxCmd) {
-      return {
-        get status() {
-          return "killed";
-        },
-        background: () => null,
-        kill: () => {
-        },
-        result: Promise.resolve({
-          stdout: "",
-          stderr: "System sandbox is required but unavailable (missing bubblewrap or unsupported platform).",
-          code: 2,
-          interrupted: false
-        })
-      };
-    }
-    const cmdToRun = sandboxCmd ? sandboxCmd.cmd : this.getShellCmd(command);
-    const internalAbortController = new AbortController();
-    this.abortController = internalAbortController;
-    let status = "running";
-    let backgroundProcess = null;
-    let backgroundTaskId = null;
-    let stdout = "";
-    let stderr = "";
-    let wasAborted = false;
-    let wasBackgrounded = false;
-    let timeoutHandle = null;
-    let timedOut = false;
-    let onTimeoutCb = null;
-    const countNonEmptyLines = (chunk) => chunk.split("\n").filter((line) => line.length > 0).length;
-    const spawnedProcess = spawnWithExited({ cmd: cmdToRun, cwd: executionCwd });
-    this.currentProcess = spawnedProcess;
-    const onAbort = () => {
-      if (status === "backgrounded") return;
-      wasAborted = true;
-      try {
-        internalAbortController.abort();
-      } catch {
       }
-      try {
-        spawnedProcess.kill();
-      } catch {
+      static getInstance() {
+        if (!_BunShell.instance || !_BunShell.instance.isAlive) {
+          _BunShell.instance = new _BunShell(process.cwd());
+        }
+        return _BunShell.instance;
       }
-      if (backgroundProcess) backgroundProcess.interrupted = true;
-    };
-    const clearForegroundGuards = () => {
-      if (timeoutHandle) {
-        clearTimeout(timeoutHandle);
-        timeoutHandle = null;
+      static getShellCmdForPlatform(platform, command, _env = process.env) {
+        if (platform === "win32") {
+          return [resolvePowerShellPath(), "-NoProfile", "-NonInteractive", "-Command", command];
+        }
+        const sh = existsSync4("/bin/sh") ? "/bin/sh" : "sh";
+        return [sh, "-c", command];
       }
-      if (abortSignal) {
-        abortSignal.removeEventListener("abort", onAbort);
+      getShellCmd(command) {
+        return _BunShell.getShellCmdForPlatform(
+          process.platform,
+          command,
+          process.env
+        );
       }
-    };
-    if (abortSignal) {
-      abortSignal.addEventListener("abort", onAbort, { once: true });
-      if (abortSignal.aborted) onAbort();
-    }
-    const stdoutCollector = this.createCancellableTextCollector(
-      spawnedProcess.stdout,
-      {
-        collectText: false,
-        onChunk: (chunk) => {
-          stdout += chunk;
-          options?.onStdoutChunk?.(chunk);
-          if (backgroundProcess) {
-            backgroundProcess.stdout = stdout;
-            appendTaskOutput(backgroundProcess.id, chunk);
-            backgroundProcess.stdoutLineCount += countNonEmptyLines(chunk);
+      buildSandboxCmd(command, sandbox) {
+        if (!sandbox.enabled) return null;
+        const platform = sandbox.__platformOverride ?? process.platform;
+        const needsNetworkRestriction = sandbox.needsNetworkRestriction !== void 0 ? sandbox.needsNetworkRestriction : sandbox.allowNetwork === true ? false : true;
+        const writeConfig = sandbox.writeConfig ?? (sandbox.writableRoots && sandbox.writableRoots.length > 0 ? { allowOnly: sandbox.writableRoots.filter(Boolean) } : void 0);
+        const readConfig = sandbox.readConfig;
+        const hasReadRestrictions = (readConfig?.denyOnly?.length ?? 0) > 0;
+        const hasWriteRestrictions = writeConfig !== void 0;
+        const hasNetworkRestrictions = needsNetworkRestriction === true;
+        if (!hasReadRestrictions && !hasWriteRestrictions && !hasNetworkRestrictions) {
+          return null;
+        }
+        const binShell = sandbox.binShell ?? (whichSync("bash") ? "bash" : "sh");
+        const binShellPath = whichOrSelf(binShell);
+        const cwd2 = sandbox.chdir || this.cwd;
+        if (platform === "linux") {
+          const bwrapPath = sandbox.__bwrapPathOverride !== void 0 ? sandbox.__bwrapPathOverride : whichSync("bwrap") ?? whichSync("bubblewrap");
+          if (!bwrapPath) {
+            return null;
+          }
+          try {
+            mkdirSync4("/tmp/newcraw", { recursive: true });
+          } catch {
           }
+          const cmd = buildLinuxBwrapCommand({
+            bwrapPath,
+            command,
+            needsNetworkRestriction,
+            readConfig,
+            writeConfig,
+            enableWeakerNestedSandbox: sandbox.enableWeakerNestedSandbox,
+            binShellPath,
+            cwd: cwd2
+          });
+          return { cmd };
         }
-      }
-    );
-    const stderrCollector = this.createCancellableTextCollector(
-      spawnedProcess.stderr,
-      {
-        collectText: false,
-        onChunk: (chunk) => {
-          stderr += chunk;
-          options?.onStderrChunk?.(chunk);
-          if (backgroundProcess) {
-            backgroundProcess.stderr = stderr;
-            appendTaskOutput(backgroundProcess.id, chunk);
-            backgroundProcess.stderrLineCount += countNonEmptyLines(chunk);
+        if (platform === "darwin") {
+          const sandboxExecPath = sandbox.__sandboxExecPathOverride !== void 0 ? sandbox.__sandboxExecPathOverride : existsSync4("/usr/bin/sandbox-exec") ? "/usr/bin/sandbox-exec" : whichSync("sandbox-exec");
+          if (!sandboxExecPath) {
+            return null;
           }
+          try {
+            mkdirSync4("/tmp/newcraw", { recursive: true });
+          } catch {
+          }
+          try {
+            mkdirSync4("/private/tmp/newcraw", { recursive: true });
+          } catch {
+          }
+          return {
+            cmd: buildMacosSandboxExecCommand({
+              sandboxExecPath,
+              binShellPath,
+              command,
+              needsNetworkRestriction,
+              httpProxyPort: sandbox.httpProxyPort,
+              socksProxyPort: sandbox.socksProxyPort,
+              allowUnixSockets: sandbox.allowUnixSockets,
+              allowAllUnixSockets: sandbox.allowAllUnixSockets,
+              allowLocalBinding: sandbox.allowLocalBinding,
+              readConfig,
+              writeConfig
+            })
+          };
         }
+        return null;
       }
-    );
-    timeoutHandle = setTimeout(() => {
-      if (status !== "running") return;
-      if (onTimeoutCb) {
-        onTimeoutCb(background);
-        return;
-      }
-      timedOut = true;
-      try {
-        spawnedProcess.kill();
-      } catch {
+      isSandboxInitFailure(stderr) {
+        const s = stderr.toLowerCase();
+        return s.includes("bwrap:") || s.includes("bubblewrap") || s.includes("namespace") && s.includes("failed");
       }
-      try {
-        internalAbortController.abort();
-      } catch {
+      startStreamReader(stream, append) {
+        if (!stream) return;
+        try {
+          ;
+          stream.setEncoding?.("utf8");
+        } catch {
+        }
+        stream.on("data", (chunk) => {
+          append(
+            typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk)
+          );
+        });
+        stream.on("error", (err) => {
+          logError(`Stream read error: ${err}`);
+        });
       }
-    }, commandTimeout);
-    const background = (bashId) => {
-      if (backgroundTaskId) return { bashId: backgroundTaskId };
-      if (status !== "running") return null;
-      backgroundTaskId = bashId ?? _BunShell.makeBackgroundTaskId();
-      const outputFile = touchTaskOutputFile(backgroundTaskId);
-      if (stdout) appendTaskOutput(backgroundTaskId, stdout);
-      if (stderr) appendTaskOutput(backgroundTaskId, stderr);
-      status = "backgrounded";
-      wasBackgrounded = true;
-      clearForegroundGuards();
-      backgroundProcess = {
-        id: backgroundTaskId,
-        command,
-        stdout,
-        stderr,
-        stdoutCursor: 0,
-        stderrCursor: 0,
-        stdoutLineCount: countNonEmptyLines(stdout),
-        stderrLineCount: countNonEmptyLines(stderr),
-        lastReportedStdoutLines: 0,
-        lastReportedStderrLines: 0,
-        code: null,
-        interrupted: false,
-        killed: false,
-        timedOut: false,
-        completionStatusSentInAttachment: false,
-        notified: false,
-        startedAt,
-        timeoutAt: Number.POSITIVE_INFINITY,
-        process: spawnedProcess,
-        abortController: internalAbortController,
-        timeoutHandle: null,
-        cwd: executionCwd,
-        outputFile
-      };
-      this.backgroundProcesses.set(backgroundTaskId, backgroundProcess);
-      this.currentProcess = null;
-      this.abortController = null;
-      return { bashId: backgroundTaskId };
-    };
-    const kill = () => {
-      status = "killed";
-      try {
-        spawnedProcess.kill();
-      } catch {
+      createCancellableTextCollector(stream, options) {
+        let text = "";
+        const collectText = options?.collectText !== false;
+        if (!stream) {
+          return {
+            getText: () => text,
+            done: Promise.resolve(),
+            cancel: async () => {
+            }
+          };
+        }
+        let cancelled = false;
+        let resolveDone = null;
+        const done = new Promise((resolve3) => {
+          resolveDone = resolve3;
+        });
+        const finish = () => {
+          if (!resolveDone) return;
+          resolveDone();
+          resolveDone = null;
+        };
+        const onData = (chunk) => {
+          if (cancelled) return;
+          const s = typeof chunk === "string" ? chunk : Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+          if (collectText) text += s;
+          options?.onChunk?.(s);
+        };
+        const onEnd = () => {
+          cleanup();
+          finish();
+        };
+        const onClose = () => {
+          cleanup();
+          finish();
+        };
+        const cleanup = () => {
+          stream.off("data", onData);
+          stream.off("end", onEnd);
+          stream.off("close", onClose);
+          stream.off("error", onError);
+        };
+        const onError = (err) => {
+          if (!cancelled) {
+            logError(`Stream read error: ${err}`);
+          }
+          cleanup();
+          finish();
+        };
+        try {
+          ;
+          stream.setEncoding?.("utf8");
+        } catch {
+        }
+        stream.on("data", onData);
+        stream.once("end", onEnd);
+        stream.once("close", onClose);
+        stream.once("error", onError);
+        return {
+          getText: () => text,
+          done,
+          cancel: async () => {
+            if (cancelled) return;
+            cancelled = true;
+            cleanup();
+            finish();
+          }
+        };
       }
-      try {
-        internalAbortController.abort();
-      } catch {
+      static makeBackgroundTaskId() {
+        return `b${randomUUID2().replace(/-/g, "").slice(0, 6)}`;
       }
-      if (backgroundProcess) {
-        backgroundProcess.interrupted = true;
-        backgroundProcess.killed = true;
+      execPromotable(command, abortSignal, timeout, options) {
+        const DEFAULT_TIMEOUT = 12e4;
+        const commandTimeout = timeout ?? DEFAULT_TIMEOUT;
+        const startedAt = Date.now();
+        const sandbox = options?.sandbox;
+        const shouldAttemptSandbox = sandbox?.enabled === true;
+        const executionCwd = shouldAttemptSandbox && sandbox?.chdir ? sandbox.chdir : this.cwd;
+        if (abortSignal?.aborted) {
+          return {
+            get status() {
+              return "killed";
+            },
+            background: () => null,
+            kill: () => {
+            },
+            result: Promise.resolve({
+              stdout: "",
+              stderr: "Command aborted before execution",
+              code: 145,
+              interrupted: true
+            })
+          };
+        }
+        const sandboxCmd = shouldAttemptSandbox ? this.buildSandboxCmd(command, sandbox) : null;
+        if (shouldAttemptSandbox && sandbox?.require && !sandboxCmd) {
+          return {
+            get status() {
+              return "killed";
+            },
+            background: () => null,
+            kill: () => {
+            },
+            result: Promise.resolve({
+              stdout: "",
+              stderr: "System sandbox is required but unavailable (missing bubblewrap or unsupported platform).",
+              code: 2,
+              interrupted: false
+            })
+          };
+        }
+        const cmdToRun = sandboxCmd ? sandboxCmd.cmd : this.getShellCmd(command);
+        const internalAbortController = new AbortController();
+        this.abortController = internalAbortController;
+        let status = "running";
+        let backgroundProcess = null;
+        let backgroundTaskId = null;
+        let stdout = "";
+        let stderr = "";
+        let wasAborted = false;
+        let wasBackgrounded = false;
+        let timeoutHandle = null;
+        let timedOut = false;
+        let onTimeoutCb = null;
+        const countNonEmptyLines = (chunk) => chunk.split("\n").filter((line) => line.length > 0).length;
+        const spawnedProcess = spawnWithExited({ cmd: cmdToRun, cwd: executionCwd });
+        this.currentProcess = spawnedProcess;
+        const onAbort = () => {
+          if (status === "backgrounded") return;
+          wasAborted = true;
+          try {
+            internalAbortController.abort();
+          } catch {
+          }
+          try {
+            spawnedProcess.kill();
+          } catch {
+          }
+          if (backgroundProcess) backgroundProcess.interrupted = true;
+        };
+        const clearForegroundGuards = () => {
+          if (timeoutHandle) {
+            clearTimeout(timeoutHandle);
+            timeoutHandle = null;
+          }
+          if (abortSignal) {
+            abortSignal.removeEventListener("abort", onAbort);
+          }
+        };
+        if (abortSignal) {
+          abortSignal.addEventListener("abort", onAbort, { once: true });
+          if (abortSignal.aborted) onAbort();
+        }
+        const stdoutCollector = this.createCancellableTextCollector(
+          spawnedProcess.stdout,
+          {
+            collectText: false,
+            onChunk: (chunk) => {
+              stdout += chunk;
+              options?.onStdoutChunk?.(chunk);
+              if (backgroundProcess) {
+                backgroundProcess.stdout = stdout;
+                appendTaskOutput(backgroundProcess.id, chunk);
+                backgroundProcess.stdoutLineCount += countNonEmptyLines(chunk);
+              }
+            }
+          }
+        );
+        const stderrCollector = this.createCancellableTextCollector(
+          spawnedProcess.stderr,
+          {
+            collectText: false,
+            onChunk: (chunk) => {
+              stderr += chunk;
+              options?.onStderrChunk?.(chunk);
+              if (backgroundProcess) {
+                backgroundProcess.stderr = stderr;
+                appendTaskOutput(backgroundProcess.id, chunk);
+                backgroundProcess.stderrLineCount += countNonEmptyLines(chunk);
+              }
+            }
+          }
+        );
+        timeoutHandle = setTimeout(() => {
+          if (status !== "running") return;
+          if (onTimeoutCb) {
+            onTimeoutCb(background);
+            return;
+          }
+          timedOut = true;
+          try {
+            spawnedProcess.kill();
+          } catch {
+          }
+          try {
+            internalAbortController.abort();
+          } catch {
+          }
+        }, commandTimeout);
+        const background = (bashId) => {
+          if (backgroundTaskId) return { bashId: backgroundTaskId };
+          if (status !== "running") return null;
+          backgroundTaskId = bashId ?? _BunShell.makeBackgroundTaskId();
+          const outputFile = touchTaskOutputFile(backgroundTaskId);
+          if (stdout) appendTaskOutput(backgroundTaskId, stdout);
+          if (stderr) appendTaskOutput(backgroundTaskId, stderr);
+          status = "backgrounded";
+          wasBackgrounded = true;
+          clearForegroundGuards();
+          backgroundProcess = {
+            id: backgroundTaskId,
+            command,
+            stdout,
+            stderr,
+            stdoutCursor: 0,
+            stderrCursor: 0,
+            stdoutLineCount: countNonEmptyLines(stdout),
+            stderrLineCount: countNonEmptyLines(stderr),
+            lastReportedStdoutLines: 0,
+            lastReportedStderrLines: 0,
+            code: null,
+            interrupted: false,
+            killed: false,
+            timedOut: false,
+            completionStatusSentInAttachment: false,
+            notified: false,
+            startedAt,
+            timeoutAt: Number.POSITIVE_INFINITY,
+            process: spawnedProcess,
+            abortController: internalAbortController,
+            timeoutHandle: null,
+            cwd: executionCwd,
+            outputFile
+          };
+          this.backgroundProcesses.set(backgroundTaskId, backgroundProcess);
+          this.currentProcess = null;
+          this.abortController = null;
+          return { bashId: backgroundTaskId };
+        };
+        const kill = () => {
+          status = "killed";
+          try {
+            spawnedProcess.kill();
+          } catch {
+          }
+          try {
+            internalAbortController.abort();
+          } catch {
+          }
+          if (backgroundProcess) {
+            backgroundProcess.interrupted = true;
+            backgroundProcess.killed = true;
+          }
+        };
+        const result = (async () => {
+          try {
+            await spawnedProcess.exited;
+            if (status === "running" || status === "backgrounded")
+              status = "completed";
+            if (backgroundProcess) {
+              backgroundProcess.code = spawnedProcess.exitCode ?? 0;
+              backgroundProcess.interrupted = backgroundProcess.interrupted || wasAborted || internalAbortController.signal.aborted;
+            }
+            if (!wasBackgrounded) {
+              await Promise.race([
+                Promise.allSettled([stdoutCollector.done, stderrCollector.done]),
+                new Promise((resolve3) => setTimeout(resolve3, 250))
+              ]);
+              await Promise.allSettled([
+                stdoutCollector.cancel(),
+                stderrCollector.cancel()
+              ]);
+            }
+            const interrupted = wasAborted || abortSignal?.aborted === true || internalAbortController.signal.aborted === true || timedOut;
+            let code = spawnedProcess.exitCode;
+            if (!Number.isFinite(code)) {
+              code = interrupted ? 143 : 0;
+            }
+            const stderrWithTimeout = timedOut ? [`Command timed out`, stderr].filter(Boolean).join("\n") : stderr;
+            const stderrAnnotated = sandboxCmd ? maybeAnnotateMacosSandboxStderr(stderrWithTimeout, sandbox) : stderrWithTimeout;
+            return {
+              stdout,
+              stderr: stderrAnnotated,
+              code,
+              interrupted
+            };
+          } finally {
+            clearForegroundGuards();
+            if (this.currentProcess === spawnedProcess) {
+              this.currentProcess = null;
+              this.abortController = null;
+            }
+          }
+        })();
+        const execHandle = {
+          get status() {
+            return status;
+          },
+          background,
+          kill,
+          result
+        };
+        execHandle.onTimeout = (cb) => {
+          onTimeoutCb = cb;
+        };
+        result.then((r) => {
+          if (!backgroundProcess || !backgroundTaskId) return;
+          backgroundProcess.code = r.code;
+          backgroundProcess.interrupted = r.interrupted;
+        }).catch(() => {
+          if (!backgroundProcess) return;
+          backgroundProcess.code = backgroundProcess.code ?? 2;
+        });
+        return execHandle;
       }
-    };
-    const result = (async () => {
-      try {
-        await spawnedProcess.exited;
-        if (status === "running" || status === "backgrounded")
-          status = "completed";
-        if (backgroundProcess) {
-          backgroundProcess.code = spawnedProcess.exitCode ?? 0;
-          backgroundProcess.interrupted = backgroundProcess.interrupted || wasAborted || internalAbortController.signal.aborted;
+      async exec(command, abortSignal, timeout, options) {
+        const DEFAULT_TIMEOUT = 12e4;
+        const commandTimeout = timeout ?? DEFAULT_TIMEOUT;
+        this.abortController = new AbortController();
+        let wasAborted = false;
+        const onAbort = () => {
+          wasAborted = true;
+          try {
+            this.abortController?.abort();
+          } catch {
+          }
+          try {
+            this.currentProcess?.kill();
+          } catch {
+          }
+        };
+        if (abortSignal) {
+          abortSignal.addEventListener("abort", onAbort, { once: true });
         }
-        if (!wasBackgrounded) {
+        const sandbox = options?.sandbox;
+        const shouldAttemptSandbox = sandbox?.enabled === true;
+        const executionCwd = shouldAttemptSandbox && sandbox?.chdir ? sandbox.chdir : this.cwd;
+        const runOnce = async (cmd, cwdOverride) => {
+          this.currentProcess = spawnWithExited({
+            cmd,
+            cwd: cwdOverride ?? executionCwd
+          });
+          const stdoutCollector = this.createCancellableTextCollector(
+            this.currentProcess.stdout,
+            { onChunk: options?.onStdoutChunk }
+          );
+          const stderrCollector = this.createCancellableTextCollector(
+            this.currentProcess.stderr,
+            { onChunk: options?.onStderrChunk }
+          );
+          let timeoutHandle = null;
+          const timeoutPromise = new Promise((resolve3) => {
+            timeoutHandle = setTimeout(() => resolve3("timeout"), commandTimeout);
+          });
+          const result = await Promise.race([
+            this.currentProcess.exited.then(() => "completed"),
+            timeoutPromise
+          ]);
+          if (timeoutHandle) clearTimeout(timeoutHandle);
+          if (result === "timeout") {
+            try {
+              this.currentProcess.kill();
+            } catch {
+            }
+            try {
+              this.abortController.abort();
+            } catch {
+            }
+            try {
+              await this.currentProcess.exited;
+            } catch {
+            }
+            await Promise.race([
+              Promise.allSettled([stdoutCollector.done, stderrCollector.done]),
+              new Promise((resolve3) => setTimeout(resolve3, 250))
+            ]);
+            await Promise.allSettled([
+              stdoutCollector.cancel(),
+              stderrCollector.cancel()
+            ]);
+            return {
+              stdout: "",
+              stderr: "Command timed out",
+              code: 143,
+              interrupted: true
+            };
+          }
           await Promise.race([
             Promise.allSettled([stdoutCollector.done, stderrCollector.done]),
             new Promise((resolve3) => setTimeout(resolve3, 250))
@@ -2493,415 +2649,292 @@ var BunShell = class _BunShell {
             stdoutCollector.cancel(),
             stderrCollector.cancel()
           ]);
-        }
-        const interrupted = wasAborted || abortSignal?.aborted === true || internalAbortController.signal.aborted === true || timedOut;
-        let code = spawnedProcess.exitCode;
-        if (!Number.isFinite(code)) {
-          code = interrupted ? 143 : 0;
-        }
-        const stderrWithTimeout = timedOut ? [`Command timed out`, stderr].filter(Boolean).join("\n") : stderr;
-        const stderrAnnotated = sandboxCmd ? maybeAnnotateMacosSandboxStderr(stderrWithTimeout, sandbox) : stderrWithTimeout;
-        return {
-          stdout,
-          stderr: stderrAnnotated,
-          code,
-          interrupted
+          const stdout = stdoutCollector.getText();
+          const stderr = stderrCollector.getText();
+          const interrupted = wasAborted || abortSignal?.aborted === true || this.abortController?.signal.aborted === true;
+          const exitCode = this.currentProcess.exitCode ?? (interrupted ? 143 : 0);
+          return {
+            stdout,
+            stderr,
+            code: exitCode,
+            interrupted
+          };
         };
-      } finally {
-        clearForegroundGuards();
-        if (this.currentProcess === spawnedProcess) {
+        try {
+          if (shouldAttemptSandbox) {
+            const sandboxCmd = this.buildSandboxCmd(command, sandbox);
+            if (!sandboxCmd) {
+              if (sandbox?.require) {
+                return {
+                  stdout: "",
+                  stderr: "System sandbox is required but unavailable (missing bubblewrap or unsupported platform).",
+                  code: 2,
+                  interrupted: false
+                };
+              }
+              const fallback = await runOnce(this.getShellCmd(command));
+              return {
+                ...fallback,
+                stderr: `[sandbox] unavailable, ran without isolation.
+${fallback.stderr}`.trim()
+              };
+            }
+            const sandboxed = await runOnce(sandboxCmd.cmd);
+            sandboxed.stderr = maybeAnnotateMacosSandboxStderr(
+              sandboxed.stderr,
+              sandbox
+            );
+            if (!sandboxed.interrupted && sandboxed.code !== 0 && this.isSandboxInitFailure(sandboxed.stderr) && !sandbox?.require) {
+              const fallback = await runOnce(this.getShellCmd(command));
+              return {
+                ...fallback,
+                stderr: `[sandbox] failed to start, ran without isolation.
+${fallback.stderr}`.trim()
+              };
+            }
+            return sandboxed;
+          }
+          return await runOnce(this.getShellCmd(command));
+        } catch (error) {
+          if (this.abortController.signal.aborted) {
+            this.currentProcess?.kill();
+            return {
+              stdout: "",
+              stderr: "Command was interrupted",
+              code: 143,
+              interrupted: true
+            };
+          }
+          const errorStr = error instanceof Error ? error.message : String(error);
+          logError(`Shell execution error: ${errorStr}`);
+          return {
+            stdout: "",
+            stderr: errorStr,
+            code: 2,
+            interrupted: false
+          };
+        } finally {
+          if (abortSignal) {
+            abortSignal.removeEventListener("abort", onAbort);
+          }
           this.currentProcess = null;
           this.abortController = null;
         }
       }
-    })();
-    const execHandle = {
-      get status() {
-        return status;
-      },
-      background,
-      kill,
-      result
-    };
-    execHandle.onTimeout = (cb) => {
-      onTimeoutCb = cb;
-    };
-    result.then((r) => {
-      if (!backgroundProcess || !backgroundTaskId) return;
-      backgroundProcess.code = r.code;
-      backgroundProcess.interrupted = r.interrupted;
-    }).catch(() => {
-      if (!backgroundProcess) return;
-      backgroundProcess.code = backgroundProcess.code ?? 2;
-    });
-    return execHandle;
-  }
-  async exec(command, abortSignal, timeout, options) {
-    const DEFAULT_TIMEOUT = 12e4;
-    const commandTimeout = timeout ?? DEFAULT_TIMEOUT;
-    this.abortController = new AbortController();
-    let wasAborted = false;
-    const onAbort = () => {
-      wasAborted = true;
-      try {
-        this.abortController?.abort();
-      } catch {
+      execInBackground(command, timeout, options) {
+        const DEFAULT_TIMEOUT = 12e4;
+        const commandTimeout = timeout ?? DEFAULT_TIMEOUT;
+        const abortController = new AbortController();
+        const sandbox = options?.sandbox;
+        const sandboxCmd = sandbox?.enabled === true ? this.buildSandboxCmd(command, sandbox) : null;
+        const executionCwd = sandbox?.enabled === true && sandbox?.chdir ? sandbox.chdir : this.cwd;
+        if (sandbox?.enabled === true && sandbox?.require && !sandboxCmd) {
+          throw new Error(
+            "System sandbox is required but unavailable (missing bubblewrap or unsupported platform)."
+          );
+        }
+        const cmdToRun = sandboxCmd ? sandboxCmd.cmd : this.getShellCmd(command);
+        const bashId = _BunShell.makeBackgroundTaskId();
+        const outputFile = touchTaskOutputFile(bashId);
+        const process2 = spawnWithExited({ cmd: cmdToRun, cwd: executionCwd });
+        const timeoutHandle = setTimeout(() => {
+          abortController.abort();
+          backgroundProcess.timedOut = true;
+          process2.kill();
+        }, commandTimeout);
+        const backgroundProcess = {
+          id: bashId,
+          command,
+          stdout: "",
+          stderr: "",
+          stdoutCursor: 0,
+          stderrCursor: 0,
+          stdoutLineCount: 0,
+          stderrLineCount: 0,
+          lastReportedStdoutLines: 0,
+          lastReportedStderrLines: 0,
+          code: null,
+          interrupted: false,
+          killed: false,
+          timedOut: false,
+          completionStatusSentInAttachment: false,
+          notified: false,
+          startedAt: Date.now(),
+          timeoutAt: Date.now() + commandTimeout,
+          process: process2,
+          abortController,
+          timeoutHandle,
+          cwd: executionCwd,
+          outputFile
+        };
+        const countNonEmptyLines = (chunk) => chunk.split("\n").filter((line) => line.length > 0).length;
+        this.startStreamReader(process2.stdout, (chunk) => {
+          backgroundProcess.stdout += chunk;
+          appendTaskOutput(bashId, chunk);
+          backgroundProcess.stdoutLineCount += countNonEmptyLines(chunk);
+        });
+        this.startStreamReader(process2.stderr, (chunk) => {
+          backgroundProcess.stderr += chunk;
+          appendTaskOutput(bashId, chunk);
+          backgroundProcess.stderrLineCount += countNonEmptyLines(chunk);
+        });
+        process2.exited.then(() => {
+          backgroundProcess.code = process2.exitCode ?? 0;
+          backgroundProcess.interrupted = backgroundProcess.interrupted || abortController.signal.aborted;
+          if (sandbox?.enabled === true) {
+            backgroundProcess.stderr = maybeAnnotateMacosSandboxStderr(
+              backgroundProcess.stderr,
+              sandbox
+            );
+          }
+          if (backgroundProcess.timeoutHandle) {
+            clearTimeout(backgroundProcess.timeoutHandle);
+            backgroundProcess.timeoutHandle = null;
+          }
+        });
+        this.backgroundProcesses.set(bashId, backgroundProcess);
+        return { bashId };
       }
-      try {
-        this.currentProcess?.kill();
-      } catch {
+      getBackgroundOutput(shellId) {
+        const proc = this.backgroundProcesses.get(shellId);
+        if (!proc) return null;
+        const running = proc.code === null && !proc.interrupted;
+        return {
+          stdout: proc.stdout,
+          stderr: proc.stderr,
+          code: proc.code,
+          interrupted: proc.interrupted,
+          killed: proc.killed,
+          timedOut: proc.timedOut,
+          running,
+          command: proc.command,
+          cwd: proc.cwd,
+          startedAt: proc.startedAt,
+          timeoutAt: proc.timeoutAt,
+          outputFile: proc.outputFile
+        };
       }
-    };
-    if (abortSignal) {
-      abortSignal.addEventListener("abort", onAbort, { once: true });
-    }
-    const sandbox = options?.sandbox;
-    const shouldAttemptSandbox = sandbox?.enabled === true;
-    const executionCwd = shouldAttemptSandbox && sandbox?.chdir ? sandbox.chdir : this.cwd;
-    const runOnce = async (cmd, cwdOverride) => {
-      this.currentProcess = spawnWithExited({
-        cmd,
-        cwd: cwdOverride ?? executionCwd
-      });
-      const stdoutCollector = this.createCancellableTextCollector(
-        this.currentProcess.stdout,
-        { onChunk: options?.onStdoutChunk }
-      );
-      const stderrCollector = this.createCancellableTextCollector(
-        this.currentProcess.stderr,
-        { onChunk: options?.onStderrChunk }
-      );
-      let timeoutHandle = null;
-      const timeoutPromise = new Promise((resolve3) => {
-        timeoutHandle = setTimeout(() => resolve3("timeout"), commandTimeout);
-      });
-      const result = await Promise.race([
-        this.currentProcess.exited.then(() => "completed"),
-        timeoutPromise
-      ]);
-      if (timeoutHandle) clearTimeout(timeoutHandle);
-      if (result === "timeout") {
-        try {
-          this.currentProcess.kill();
-        } catch {
-        }
-        try {
-          this.abortController.abort();
-        } catch {
-        }
-        try {
-          await this.currentProcess.exited;
-        } catch {
+      readBackgroundOutput(bashId, options) {
+        const proc = this.backgroundProcesses.get(bashId);
+        if (!proc) return null;
+        const stdoutDelta = proc.stdout.slice(proc.stdoutCursor);
+        const stderrDelta = proc.stderr.slice(proc.stderrCursor);
+        proc.stdoutCursor = proc.stdout.length;
+        proc.stderrCursor = proc.stderr.length;
+        const stdoutLines = stdoutDelta === "" ? 0 : stdoutDelta.split("\n").length;
+        const stderrLines = stderrDelta === "" ? 0 : stderrDelta.split("\n").length;
+        let stdoutToReturn = stdoutDelta;
+        let stderrToReturn = stderrDelta;
+        const filter = options?.filter?.trim();
+        if (filter) {
+          const regex = new RegExp(filter, "i");
+          stdoutToReturn = stdoutDelta.split("\n").filter((line) => regex.test(line)).join("\n");
+          stderrToReturn = stderrDelta.split("\n").filter((line) => regex.test(line)).join("\n");
         }
-        await Promise.race([
-          Promise.allSettled([stdoutCollector.done, stderrCollector.done]),
-          new Promise((resolve3) => setTimeout(resolve3, 250))
-        ]);
-        await Promise.allSettled([
-          stdoutCollector.cancel(),
-          stderrCollector.cancel()
-        ]);
+        const status = proc.killed ? "killed" : proc.code === null ? "running" : proc.code === 0 ? "completed" : "failed";
         return {
-          stdout: "",
-          stderr: "Command timed out",
-          code: 143,
-          interrupted: true
+          shellId: bashId,
+          command: proc.command,
+          cwd: proc.cwd,
+          startedAt: proc.startedAt,
+          timeoutAt: proc.timeoutAt,
+          status,
+          exitCode: proc.code,
+          stdout: stdoutToReturn,
+          stderr: stderrToReturn,
+          stdoutLines,
+          stderrLines,
+          ...filter ? { filterPattern: filter } : {}
         };
       }
-      await Promise.race([
-        Promise.allSettled([stdoutCollector.done, stderrCollector.done]),
-        new Promise((resolve3) => setTimeout(resolve3, 250))
-      ]);
-      await Promise.allSettled([
-        stdoutCollector.cancel(),
-        stderrCollector.cancel()
-      ]);
-      const stdout = stdoutCollector.getText();
-      const stderr = stderrCollector.getText();
-      const interrupted = wasAborted || abortSignal?.aborted === true || this.abortController?.signal.aborted === true;
-      const exitCode = this.currentProcess.exitCode ?? (interrupted ? 143 : 0);
-      return {
-        stdout,
-        stderr,
-        code: exitCode,
-        interrupted
-      };
-    };
-    try {
-      if (shouldAttemptSandbox) {
-        const sandboxCmd = this.buildSandboxCmd(command, sandbox);
-        if (!sandboxCmd) {
-          if (sandbox?.require) {
-            return {
-              stdout: "",
-              stderr: "System sandbox is required but unavailable (missing bubblewrap or unsupported platform).",
-              code: 2,
-              interrupted: false
-            };
+      killBackgroundShell(shellId) {
+        const proc = this.backgroundProcesses.get(shellId);
+        if (!proc) return false;
+        try {
+          proc.interrupted = true;
+          proc.killed = true;
+          proc.abortController.abort();
+          proc.process.kill();
+          if (proc.timeoutHandle) {
+            clearTimeout(proc.timeoutHandle);
+            proc.timeoutHandle = null;
           }
-          const fallback = await runOnce(this.getShellCmd(command));
-          return {
-            ...fallback,
-            stderr: `[sandbox] unavailable, ran without isolation.
-${fallback.stderr}`.trim()
-          };
+          return true;
+        } catch {
+          return false;
         }
-        const sandboxed = await runOnce(sandboxCmd.cmd);
-        sandboxed.stderr = maybeAnnotateMacosSandboxStderr(
-          sandboxed.stderr,
-          sandbox
-        );
-        if (!sandboxed.interrupted && sandboxed.code !== 0 && this.isSandboxInitFailure(sandboxed.stderr) && !sandbox?.require) {
-          const fallback = await runOnce(this.getShellCmd(command));
-          return {
-            ...fallback,
-            stderr: `[sandbox] failed to start, ran without isolation.
-${fallback.stderr}`.trim()
-          };
+      }
+      listBackgroundShells() {
+        return Array.from(this.backgroundProcesses.values());
+      }
+      pwd() {
+        return this.cwd;
+      }
+      async setCwd(cwd2) {
+        const resolved = isAbsolute2(cwd2) ? cwd2 : resolve2(this.cwd, cwd2);
+        if (!existsSync4(resolved)) {
+          throw new Error(`Path "${resolved}" does not exist`);
         }
-        return sandboxed;
+        this.cwd = resolved;
       }
-      return await runOnce(this.getShellCmd(command));
-    } catch (error) {
-      if (this.abortController.signal.aborted) {
+      killChildren() {
+        this.abortController?.abort();
         this.currentProcess?.kill();
-        return {
-          stdout: "",
-          stderr: "Command was interrupted",
-          code: 143,
-          interrupted: true
-        };
+        for (const bg of Array.from(this.backgroundProcesses.keys())) {
+          this.killBackgroundShell(bg);
+        }
       }
-      const errorStr = error instanceof Error ? error.message : String(error);
-      logError(`Shell execution error: ${errorStr}`);
-      return {
-        stdout: "",
-        stderr: errorStr,
-        code: 2,
-        interrupted: false
-      };
-    } finally {
-      if (abortSignal) {
-        abortSignal.removeEventListener("abort", onAbort);
+      close() {
+        this.isAlive = false;
+        this.killChildren();
       }
-      this.currentProcess = null;
-      this.abortController = null;
-    }
-  }
-  execInBackground(command, timeout, options) {
-    const DEFAULT_TIMEOUT = 12e4;
-    const commandTimeout = timeout ?? DEFAULT_TIMEOUT;
-    const abortController = new AbortController();
-    const sandbox = options?.sandbox;
-    const sandboxCmd = sandbox?.enabled === true ? this.buildSandboxCmd(command, sandbox) : null;
-    const executionCwd = sandbox?.enabled === true && sandbox?.chdir ? sandbox.chdir : this.cwd;
-    if (sandbox?.enabled === true && sandbox?.require && !sandboxCmd) {
-      throw new Error(
-        "System sandbox is required but unavailable (missing bubblewrap or unsupported platform)."
-      );
-    }
-    const cmdToRun = sandboxCmd ? sandboxCmd.cmd : this.getShellCmd(command);
-    const bashId = _BunShell.makeBackgroundTaskId();
-    const outputFile = touchTaskOutputFile(bashId);
-    const process2 = spawnWithExited({ cmd: cmdToRun, cwd: executionCwd });
-    const timeoutHandle = setTimeout(() => {
-      abortController.abort();
-      backgroundProcess.timedOut = true;
-      process2.kill();
-    }, commandTimeout);
-    const backgroundProcess = {
-      id: bashId,
-      command,
-      stdout: "",
-      stderr: "",
-      stdoutCursor: 0,
-      stderrCursor: 0,
-      stdoutLineCount: 0,
-      stderrLineCount: 0,
-      lastReportedStdoutLines: 0,
-      lastReportedStderrLines: 0,
-      code: null,
-      interrupted: false,
-      killed: false,
-      timedOut: false,
-      completionStatusSentInAttachment: false,
-      notified: false,
-      startedAt: Date.now(),
-      timeoutAt: Date.now() + commandTimeout,
-      process: process2,
-      abortController,
-      timeoutHandle,
-      cwd: executionCwd,
-      outputFile
-    };
-    const countNonEmptyLines = (chunk) => chunk.split("\n").filter((line) => line.length > 0).length;
-    this.startStreamReader(process2.stdout, (chunk) => {
-      backgroundProcess.stdout += chunk;
-      appendTaskOutput(bashId, chunk);
-      backgroundProcess.stdoutLineCount += countNonEmptyLines(chunk);
-    });
-    this.startStreamReader(process2.stderr, (chunk) => {
-      backgroundProcess.stderr += chunk;
-      appendTaskOutput(bashId, chunk);
-      backgroundProcess.stderrLineCount += countNonEmptyLines(chunk);
-    });
-    process2.exited.then(() => {
-      backgroundProcess.code = process2.exitCode ?? 0;
-      backgroundProcess.interrupted = backgroundProcess.interrupted || abortController.signal.aborted;
-      if (sandbox?.enabled === true) {
-        backgroundProcess.stderr = maybeAnnotateMacosSandboxStderr(
-          backgroundProcess.stderr,
-          sandbox
-        );
+      flushBashNotifications() {
+        const processes = Array.from(this.backgroundProcesses.values());
+        const statusFor = (proc) => proc.killed ? "killed" : proc.code === null ? "running" : proc.code === 0 ? "completed" : "failed";
+        const notifications = [];
+        for (const proc of processes) {
+          if (proc.notified) continue;
+          const status = statusFor(proc);
+          if (status === "running") continue;
+          notifications.push({
+            type: "bash_notification",
+            taskId: proc.id,
+            description: proc.command,
+            outputFile: proc.outputFile || getTaskOutputFilePath(proc.id),
+            status,
+            ...proc.code !== null ? { exitCode: proc.code } : {}
+          });
+          proc.notified = true;
+        }
+        return notifications;
       }
-      if (backgroundProcess.timeoutHandle) {
-        clearTimeout(backgroundProcess.timeoutHandle);
-        backgroundProcess.timeoutHandle = null;
+      flushBackgroundShellStatusAttachments() {
+        const processes = Array.from(this.backgroundProcesses.values());
+        const statusFor = (proc) => proc.killed ? "killed" : proc.code === null ? "running" : proc.code === 0 ? "completed" : "failed";
+        const progressAttachments = [];
+        for (const proc of processes) {
+          if (statusFor(proc) !== "running") continue;
+          const stdoutDelta = proc.stdoutLineCount - proc.lastReportedStdoutLines;
+          const stderrDelta = proc.stderrLineCount - proc.lastReportedStderrLines;
+          if (stdoutDelta === 0 && stderrDelta === 0) continue;
+          proc.lastReportedStdoutLines = proc.stdoutLineCount;
+          proc.lastReportedStderrLines = proc.stderrLineCount;
+          progressAttachments.push({
+            type: "task_progress",
+            taskId: proc.id,
+            stdoutLineDelta: stdoutDelta,
+            stderrLineDelta: stderrDelta,
+            outputFile: proc.outputFile || getTaskOutputFilePath(proc.id)
+          });
+        }
+        return progressAttachments;
       }
-    });
-    this.backgroundProcesses.set(bashId, backgroundProcess);
-    return { bashId };
-  }
-  getBackgroundOutput(shellId) {
-    const proc = this.backgroundProcesses.get(shellId);
-    if (!proc) return null;
-    const running = proc.code === null && !proc.interrupted;
-    return {
-      stdout: proc.stdout,
-      stderr: proc.stderr,
-      code: proc.code,
-      interrupted: proc.interrupted,
-      killed: proc.killed,
-      timedOut: proc.timedOut,
-      running,
-      command: proc.command,
-      cwd: proc.cwd,
-      startedAt: proc.startedAt,
-      timeoutAt: proc.timeoutAt,
-      outputFile: proc.outputFile
     };
   }
-  readBackgroundOutput(bashId, options) {
-    const proc = this.backgroundProcesses.get(bashId);
-    if (!proc) return null;
-    const stdoutDelta = proc.stdout.slice(proc.stdoutCursor);
-    const stderrDelta = proc.stderr.slice(proc.stderrCursor);
-    proc.stdoutCursor = proc.stdout.length;
-    proc.stderrCursor = proc.stderr.length;
-    const stdoutLines = stdoutDelta === "" ? 0 : stdoutDelta.split("\n").length;
-    const stderrLines = stderrDelta === "" ? 0 : stderrDelta.split("\n").length;
-    let stdoutToReturn = stdoutDelta;
-    let stderrToReturn = stderrDelta;
-    const filter = options?.filter?.trim();
-    if (filter) {
-      const regex = new RegExp(filter, "i");
-      stdoutToReturn = stdoutDelta.split("\n").filter((line) => regex.test(line)).join("\n");
-      stderrToReturn = stderrDelta.split("\n").filter((line) => regex.test(line)).join("\n");
-    }
-    const status = proc.killed ? "killed" : proc.code === null ? "running" : proc.code === 0 ? "completed" : "failed";
-    return {
-      shellId: bashId,
-      command: proc.command,
-      cwd: proc.cwd,
-      startedAt: proc.startedAt,
-      timeoutAt: proc.timeoutAt,
-      status,
-      exitCode: proc.code,
-      stdout: stdoutToReturn,
-      stderr: stderrToReturn,
-      stdoutLines,
-      stderrLines,
-      ...filter ? { filterPattern: filter } : {}
-    };
-  }
-  killBackgroundShell(shellId) {
-    const proc = this.backgroundProcesses.get(shellId);
-    if (!proc) return false;
-    try {
-      proc.interrupted = true;
-      proc.killed = true;
-      proc.abortController.abort();
-      proc.process.kill();
-      if (proc.timeoutHandle) {
-        clearTimeout(proc.timeoutHandle);
-        proc.timeoutHandle = null;
-      }
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  listBackgroundShells() {
-    return Array.from(this.backgroundProcesses.values());
-  }
-  pwd() {
-    return this.cwd;
-  }
-  async setCwd(cwd2) {
-    const resolved = isAbsolute2(cwd2) ? cwd2 : resolve2(this.cwd, cwd2);
-    if (!existsSync4(resolved)) {
-      throw new Error(`Path "${resolved}" does not exist`);
-    }
-    this.cwd = resolved;
-  }
-  killChildren() {
-    this.abortController?.abort();
-    this.currentProcess?.kill();
-    for (const bg of Array.from(this.backgroundProcesses.keys())) {
-      this.killBackgroundShell(bg);
-    }
-  }
-  close() {
-    this.isAlive = false;
-    this.killChildren();
-  }
-  flushBashNotifications() {
-    const processes = Array.from(this.backgroundProcesses.values());
-    const statusFor = (proc) => proc.killed ? "killed" : proc.code === null ? "running" : proc.code === 0 ? "completed" : "failed";
-    const notifications = [];
-    for (const proc of processes) {
-      if (proc.notified) continue;
-      const status = statusFor(proc);
-      if (status === "running") continue;
-      notifications.push({
-        type: "bash_notification",
-        taskId: proc.id,
-        description: proc.command,
-        outputFile: proc.outputFile || getTaskOutputFilePath(proc.id),
-        status,
-        ...proc.code !== null ? { exitCode: proc.code } : {}
-      });
-      proc.notified = true;
-    }
-    return notifications;
-  }
-  flushBackgroundShellStatusAttachments() {
-    const processes = Array.from(this.backgroundProcesses.values());
-    const statusFor = (proc) => proc.killed ? "killed" : proc.code === null ? "running" : proc.code === 0 ? "completed" : "failed";
-    const progressAttachments = [];
-    for (const proc of processes) {
-      if (statusFor(proc) !== "running") continue;
-      const stdoutDelta = proc.stdoutLineCount - proc.lastReportedStdoutLines;
-      const stderrDelta = proc.stderrLineCount - proc.lastReportedStderrLines;
-      if (stdoutDelta === 0 && stderrDelta === 0) continue;
-      proc.lastReportedStdoutLines = proc.stdoutLineCount;
-      proc.lastReportedStderrLines = proc.stderrLineCount;
-      progressAttachments.push({
-        type: "task_progress",
-        taskId: proc.id,
-        stdoutLineDelta: stdoutDelta,
-        stderrLineDelta: stderrDelta,
-        outputFile: proc.outputFile || getTaskOutputFilePath(proc.id)
-      });
-    }
-    return progressAttachments;
-  }
-};
+});
 // src/utils/state/index.ts
-var STATE = {
-  originalCwd: cwd()
-};
+import { cwd } from "process";
 async function setCwd(cwd2) {
   await BunShell.getInstance().setCwd(cwd2);
 }
@@ -2914,37 +2947,47 @@ function getOriginalCwd() {
 function getCwd() {
   return BunShell.getInstance().pwd();
 }
+var STATE;
+var init_state = __esm({
+  "src/utils/state/index.ts"() {
+    init_shell();
+    STATE = {
+      originalCwd: cwd()
+    };
+  }
+});
 export {
   initSentry,
   captureException,
-  PRODUCT_NAME,
-  PROJECT_FILE,
-  PRODUCT_COMMAND,
-  CONFIG_BASE_DIR,
-  GITHUB_ISSUES_REPO_URL,
-  ASCII_LOGO,
+  init_sentry,
   getTaskOutputFilePath,
   readTaskOutput,
+  init_taskOutputStore,
   detectRuntimeShell,
   renderBackgroundShellStatusAttachment,
   renderBashNotification,
   BunShell,
+  init_shell,
   setCwd,
   setOriginalCwd,
   getOriginalCwd,
   getCwd,
+  init_state,
   execFileNoThrow,
-  getKodeBaseDir,
+  init_execFileNoThrow,
+  getNewcrawBaseDir,
   getGlobalConfigFilePath,
   getMemoryDir,
   NEWCRAW_BASE_DIR,
   GLOBAL_CONFIG_FILE,
   MEMORY_DIR,
   env,
+  init_env,
   PLAN_SLUG_ADJECTIVES,
   PLAN_SLUG_VERBS,
   PLAN_SLUG_NOUNS,
+  init_planSlugWords,
   getPlanConversationKey,
   setActivePlanConversationKey,
   getPlanModeSystemPromptAdditions,
@@ -2955,6 +2998,7 @@ export {
   getPlanFilePath,
   isMainPlanFilePathForActiveConversation,
   readPlanFile,
+  init_planMode,
   SESSION_ID,
   CACHE_PATHS,
   dateToFilename,
@@ -2966,5 +3010,6 @@ export {
   getNextAvailableLogForkNumber,
   getNextAvailableLogSidechainNumber,
   formatDate,
-  logMCPError
+  logMCPError,
+  init_log
 };