thincoder 0.12.2 → 0.12.3

package/src/session.mjs

@@ -1,20 +1,33 @@
 /**
- * session.mjs — session persistence
- * Each project (keyed by cwd hash) keeps up to 5 session slots, rotated by last-access time.
- * Two recovery needs stored separately: agent recovery (history) needs context continuity, user recovery (display) needs WYSIWYG.
+ * session.mjs — session persistence (slot-based model)
+ * Each project (keyed by cwd hash) keeps up to 5 session slots.
+ * Every session lives in a numbered slot; the manifest tracks which slot is active.
+ * There is no separate "current" file — the active slot IS the current session.
  *
- * File layout: {hash}.json (current), {hash}.json.1~5 (slots), {hash}.json.manifest (slot metadata)
+ * File layout: {hash}.json.1~5 (slots), {hash}.json.manifest (slot metadata + active pointer).
+ * Legacy {hash}.json is migrated to a slot on first access.
  */
 
 import { createHash } from "node:crypto"
-import { mkdirSync, readFileSync, writeFileSync, renameSync, copyFileSync, unlinkSync, existsSync } from "node:fs"
+import { mkdirSync, readFileSync, writeFileSync, renameSync, unlinkSync, existsSync } from "node:fs"
 import { join, dirname } from "node:path"
+import { execSync } from "node:child_process"
 import { configDir } from "./config.mjs"
 
 const MAX_SLOTS = 5
 const CWD_HASH_LEN = 12
 
-/** Derive session file path from cwd hash */
+let currentSessionId = null
+
+/** Generate unique session ID for this process */
+export function getSessionId() {
+  if (!currentSessionId) {
+    currentSessionId = `${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+  }
+  return currentSessionId
+}
+
+/** Derive base session path from cwd hash (legacy, kept for migration and tests) */
 export function sessionPath(cwd) {
   const hash = createHash("sha1").update(cwd).digest("hex").slice(0, CWD_HASH_LEN)
   return join(configDir, "sessions", `${hash}.json`)
@@ -23,9 +36,12 @@ export function sessionPath(cwd) {
 function slotPath(cwd, n) { return sessionPath(cwd) + "." + n }
 function manifestPath(cwd) { return sessionPath(cwd) + ".manifest" }
 
-/** Atomic write: write to temp file then rename to replace, preventing truncated JSON from mid-write crash.
- *  rename is atomic on POSIX; on Windows with existing target, Node 24 uses MoveFileExW+REPLACE_EXISTING for atomic replace.
- *  Some older Windows filesystems may throw EPERM — retry once. */
+/** Path to the active slot's file */
+export function activePath(cwd) {
+  return slotPath(cwd, activeSlot(cwd))
+}
+
+/** Atomic write: write to temp file then rename to replace, preventing truncated JSON from mid-write crash. */
 function writeSessionFile(p, data) {
   mkdirSync(dirname(p), { recursive: true })
   const tmp = `${p}.tmp`
@@ -33,15 +49,11 @@ function writeSessionFile(p, data) {
   try {
     renameSync(tmp, p)
   } catch {
-    // Windows: rename may fail due to antivirus lock / network drive contention — delete target and retry
     try { unlinkSync(p) } catch {}
     try {
       renameSync(tmp, p)
-      // rename succeeded: clean up temp file
       try { unlinkSync(tmp) } catch {}
     } catch {
-      // rename still failed — fall back to direct write (non-atomic but data-preserving)
-      // p was deleted above; avoid losing both old and new data
       writeFileSync(p, readFileSync(tmp, "utf8"), "utf8")
     }
   }
@@ -49,86 +61,188 @@ function writeSessionFile(p, data) {
 
 // ========== slot management ==========
 
+/** Normalize slot metadata: old format is a raw timestamp number; new format is { ts, ... } object */
+function slotMetaTs(v) { return typeof v === "number" ? v : (v?.ts ?? 0) }
+
+function slotCmp(a, b) { return slotMetaTs(a[1]) - slotMetaTs(b[1]) }
+
+/** Detect a genuine user message (excludes system-reminder injected messages) */
+function isRealUserMsg(m) {
+  return m.role === "user" && typeof m.content === "string" && !m.content.startsWith("[System reminder:")
+}
+
+/** Extract slot metadata from history (shared by slotDigest and loadSlotMeta) */
+function extractSlotMeta(history, activeProvider, updatedAt) {
+  const userMsgs = history.filter(isRealUserMsg)
+  const first = userMsgs[0]?.content ?? ""
+  return {
+    messageCount: history.length,
+    turnCount: userMsgs.length,
+    firstMessage: first.slice(0, 80),
+    activeProvider: activeProvider ?? "",
+    updatedAt: updatedAt ?? Date.now(),
+  }
+}
+
+/** Extract preview summary from session data for manifest storage (with current timestamp) */
+function slotDigest(data) {
+  const meta = extractSlotMeta(data.history ?? [], data.activeProvider, data.updatedAt)
+  return { ts: Date.now(), ...meta }
+}
+
 function loadManifest(cwd) {
   try {
     const p = manifestPath(cwd)
-    if (!existsSync(p)) return { slots: {} }
-    return JSON.parse(readFileSync(p, "utf8"))
-  } catch { return { slots: {} } }
+    if (!existsSync(p)) return { slots: {}, sessionId: null }
+    const m = JSON.parse(readFileSync(p, "utf8"))
+    if (!m.sessionId) m.sessionId = null
+    return m
+  } catch { return { slots: {}, sessionId: null } }
 }
 
 function saveManifest(cwd, m) {
+  m.sessionId = getSessionId()
   writeSessionFile(manifestPath(cwd), m)
 }
 
-/** Archive current session to a free slot — evict oldest if full; exclude specifies a slot that must not be evicted (switchToSlot target) */
-export function archiveCurrent(cwd, { exclude } = {}) {
-  const src = sessionPath(cwd)
-  if (!existsSync(src)) return
-  const m = loadManifest(cwd)
+/**
+ * Ensure an active slot exists in the manifest, migrating legacy data if needed.
+ * Called by activeSlot() — idempotent, safe to call repeatedly.
+ */
+function ensureActive(cwd, m) {
+  const mySessionId = getSessionId()
+  
+  // Initialize slotSessions if not present
+  if (!m.slotSessions) m.slotSessions = {}
+  
+  // Check if we already own the active slot
+  if (m.active && m.slotSessions[m.active] === mySessionId) {
+    return
+  }
+  
+  // Try to find an available slot:
+  // 1. Empty slots (not in slotSessions)
+  // 2. Slots owned by dead processes (check if PID is still running)
+  // 3. Oldest slot if all are busy
+  
+  const allSlots = Object.keys(m.slots).filter(n => /^\d+$/.test(n)).map(Number).sort((a, b) => a - b)
+  
+  // Find first empty or dead slot
+  for (const slot of allSlots) {
+    const ownerSessionId = m.slotSessions[slot]
+    if (!ownerSessionId) {
+      // Empty slot - claim it
+      m.active = slot
+      m.slotSessions[slot] = mySessionId
+      saveManifest(cwd, m)
+      return
+    }
+    if (ownerSessionId !== mySessionId) {
+      // Check if owner process is still alive
+      const ownerPid = parseInt(ownerSessionId.split('-')[0])
+      if (!isProcessAlive(ownerPid)) {
+        // Dead process - reclaim slot
+        m.active = slot
+        m.slotSessions[slot] = mySessionId
+        saveManifest(cwd, m)
+        return
+      }
+    }
+  }
+  
+  // All slots busy - create new slot if under limit, otherwise use oldest
+  if (allSlots.length < MAX_SLOTS) {
+    const newSlot = allSlots.length > 0 ? Math.max(...allSlots) + 1 : 1
+    m.active = newSlot
+    m.slotSessions[newSlot] = mySessionId
+    saveManifest(cwd, m)
+    return
+  }
+  
+  // All slots busy and at limit - use oldest slot (smallest number)
+  m.active = allSlots[0]
+  m.slotSessions[m.active] = mySessionId
+  saveManifest(cwd, m)
+}
 
-  let slot
-  // Only count numeric-keyed slots, exclude legacy non-numeric keys like _currentName
-  const entries = Object.entries(m.slots).filter(([n]) => /^\d+$/.test(n))
-  if (entries.length < MAX_SLOTS) {
-    slot = 1
-    while (m.slots[slot]) slot++
-  } else {
-    const candidates = entries.filter(([n]) => Number(n) !== exclude)
-    slot = Number((candidates.length ? candidates : entries).sort((a, b) => a[1] - b[1])[0][0])
+/**
+ * Check if a process with given PID is still alive.
+ * Returns false if process doesn't exist or we can't determine.
+ */
+function isProcessAlive(pid) {
+  if (!pid || isNaN(pid)) return false
+  try {
+    // On Windows: tasklist /FI "PID eq <pid>" /NH
+    // On Unix: kill(pid, 0) or check /proc/<pid>
+    if (process.platform === 'win32') {
+      const output = execSync(`tasklist /FI "PID eq ${pid}" /NH`, { encoding: 'utf8', stdio: 'pipe' })
+      return output.includes(String(pid))
+    } else {
+      // Unix: try to send signal 0 (doesn't kill, just checks)
+      process.kill(pid, 0)
+      return true
+    }
+  } catch {
+    return false
   }
+}
+
+/** Return the active slot number, migrating legacy data if necessary */
+export function activeSlot(cwd) {
+  const m = loadManifest(cwd)
+  if (!m.active) ensureActive(cwd, m)
+  return m.active
+}
 
-  const dst = slotPath(cwd, slot)
-  // Copy (rename would lose current); use atomic write to prevent truncated JSON in archive from mid-crash
-  let data
+/** Lazy-load slot metadata from slot file (for old-format manifest entries that lack metadata) */
+function loadSlotMeta(cwd, slot, v) {
+  if (typeof v === "object" && v !== null && "ts" in v) return v
+  const ts = typeof v === "number" ? v : 0
   try {
-    data = JSON.parse(readFileSync(src, "utf8"))
+    const p = slotPath(cwd, slot)
+    if (!existsSync(p)) return { ts }
+    const data = JSON.parse(readFileSync(p, "utf8"))
+    const history = data.history ?? []
+    const meta = extractSlotMeta(history, data.activeProvider, data.updatedAt ?? ts)
+    return { ts, ...meta }
   } catch {
-    // Session file corrupted, abandon archive; next save will overwrite
-    return
+    return { ts }
   }
-  writeSessionFile(dst, data)
-  m.slots[slot] = Date.now()
-  delete m.slots._currentName
-  saveManifest(cwd, m)
-  return slot
 }
 
-/** List all archive slots, newest first */
+/** List all slots, newest first. Includes isActive flag. */
 export function listSlots(cwd) {
   const m = loadManifest(cwd)
+  const active = m.active ?? activeSlot(cwd)
   return Object.entries(m.slots)
-    .map(([n, ts]) => ({ slot: Number(n), timestamp: ts, date: new Date(ts).toLocaleString() }))
-    .sort((a, b) => b.timestamp - a.timestamp)
+    .filter(([n]) => /^\d+$/.test(n))
+    .map(([n, v]) => {
+      const meta = loadSlotMeta(cwd, Number(n), v)
+      return {
+        slot: Number(n),
+        isActive: Number(n) === active,
+        timestamp: meta.ts,
+        date: new Date(meta.ts).toLocaleString(),
+        messageCount: meta.messageCount ?? 0,
+        turnCount: meta.turnCount ?? 0,
+        firstMessage: meta.firstMessage ?? "",
+        activeProvider: meta.activeProvider ?? "",
+        updatedAt: meta.updatedAt ?? meta.ts,
+        updatedDate: new Date(meta.updatedAt ?? meta.ts).toLocaleString(),
+      }
+    })
+    .sort((a, b) => b.updatedAt - a.updatedAt)
 }
 
-/** Switch to a specific slot: archive current → copy slot file to current → return recovered data (null on failure) */
+/**
+ * Switch active slot. No file copying — just change the pointer in the manifest.
+ * Returns the loaded session data (null if slot doesn't exist).
+ */
 export function switchToSlot(cwd, slot) {
   const m = loadManifest(cwd)
   if (!m.slots[slot]) return null
-
-  // Archive current (internally writes manifest; our `m` is stale after, must reload)
-  // When full, exclude target slot: otherwise oldest=target, archive would overwrite target then copy back, permanently losing the target session
-  archiveCurrent(cwd, { exclude: slot })
-
-  // Slot file → current (copy+unlink, not rename: Windows rename on existing target throws EPERM)
-  const src = slotPath(cwd, slot)
-  const dst = sessionPath(cwd)
-  if (!existsSync(src)) return null
-  try {
-    try { unlinkSync(dst) } catch { /* doesn't exist, that's fine */ }
-    copyFileSync(src, dst)
-    unlinkSync(src)
-  } catch {
-    // File operations failed (disk full / permissions / lock), abandon switch
-    return null
-  }
-
-  // Reload manifest (archiveCurrent modified it)
-  const m2 = loadManifest(cwd)
-  delete m2.slots[slot]
-  saveManifest(cwd, m2)
-
+  m.active = slot
+  saveManifest(cwd, m)
   return loadSession(cwd)
 }
 
@@ -149,28 +263,41 @@ function isLegacyTransient(m) {
 
 // ========== core read/write ==========
 
-/** Save agent state and display lines to the session file (atomic write) */
+/** Save agent state and display lines to the active slot file (atomic write) */
 export function saveSession(agent, display) {
   const history = agent.history.filter((m) => !m.transient && !isLegacyTransient(m))
   const data = {
     version: 2,
     cwd: agent.cwd,
     activeProvider: agent.activeProvider ?? agent.provider?.name,
+    activeModel: agent.activeModel ?? null,
     updatedAt: Date.now(),
     history,
     display: display ?? [],
     tasks: agent.tasks ?? [],
     planMode: agent.planMode ?? false,
     autoApprove: agent.autoApprove ?? false,
+    engineering: agent.config?.agent?.engineering ?? false,
+    engDesignToken: agent._engDesignToken ?? null,
     goal: agent.goal ?? null,
     advisor: agent.config?.advisor ?? null,
     pendingReminders: agent._pendingReminders ?? [],
     sessionStart: agent._sessionStart ?? null,
   }
-  writeSessionFile(sessionPath(agent.cwd), data)
+  const slot = activeSlot(agent.cwd)
+  writeSessionFile(slotPath(agent.cwd, slot), data)
+  // Update slot metadata in manifest
+  try {
+    const m = loadManifest(agent.cwd)
+    m.slots[slot] = slotDigest(data)
+    saveManifest(agent.cwd, m)
+  } catch (e) {
+    // Manifest update failure is non-fatal — data is safe, metadata will lazy-recover on next listSlots
+    console.error(`[session] manifest metadata update failed for slot ${slot}: ${e.message}`)
+  }
 }
 
-/** Load session data from disk; returns null if missing, corrupted, or version mismatch */
+/** Load session data from the active slot; returns null if missing, corrupted, or version mismatch */
 export function loadSession(cwd) {
   const tryLoad = (p) => {
     try {
@@ -189,23 +316,36 @@ export function loadSession(cwd) {
       return { _error: e }
     }
   }
-  const p = sessionPath(cwd)
+
+  // Try the active slot first (post-migration, legacy file may be stale)
+  const slot = activeSlot(cwd)
+  const p = slotPath(cwd, slot)
   let result = tryLoad(p)
+  if (result && !result._error) return result
   if (result?._error) {
-    // Main file corrupted — try the .tmp fallback from a failed atomic write
-    console.error(`[session] failed to load ${p}: ${result._error.message}. Trying .tmp fallback...`)
+    console.error(`[session] failed to load slot ${slot}: ${result._error.message}. Trying .tmp fallback...`)
     const tmpResult = tryLoad(`${p}.tmp`)
     if (tmpResult && !tmpResult._error) {
       console.error(`[session] recovered from .tmp fallback`)
-      result = tmpResult
-      result._recovered = true
-    } else {
-      console.error(`[session] .tmp fallback also failed — session lost. Backing up corrupted file as .corrupted.`)
-      try { renameSync(p, `${p}.corrupted`) } catch (e) { console.error(`[session] rename to .corrupted also failed: ${e.message}`) }
-      return null
+      tmpResult._recovered = true
+      return tmpResult
     }
+    console.error(`[session] .tmp fallback also failed — session lost.`)
+    try { renameSync(p, `${p}.corrupted`) } catch {}
+  }
+
+  // Fallback: try the legacy current file (pre-migration, or migration failed to clean up)
+  const legacy = sessionPath(cwd)
+  result = tryLoad(legacy)
+  if (result && !result._error) {
+    return result
   }
-  return result && !result._error ? result : null
+  if (result?._error) {
+    console.error(`[session] failed to load legacy ${legacy}: ${result._error.message}`)
+    try { renameSync(legacy, `${legacy}.corrupted`) } catch {}
+  }
+
+  return null
 }
 
 /** Apply loaded session data onto an agent object; returns true if provider was switched */
@@ -217,6 +357,7 @@ export function applySession(agent, data) {
   agent.goal = data.goal ?? null
   agent._pendingReminders = data.pendingReminders ?? []
   agent._sessionStart = data.sessionStart ?? null
+  agent._engDesignToken = data.engDesignToken ?? null
   if (data.advisor) {
     agent.config.advisor = { ...data.advisor }
   }
@@ -229,19 +370,59 @@ export function applySession(agent, data) {
     if (p) {
       agent.provider = { ...p }
       agent.activeProvider = p.name
+      agent.activeModel = data.activeModel ?? null
+      if (agent.activeModel) agent.provider.model = agent.activeModel
       return true
     }
+  } else if (data.activeModel != null) {
+    // Same provider, different model
+    agent.activeModel = data.activeModel
+    if (agent.activeModel && agent.provider) agent.provider.model = agent.activeModel
+  } else if (data.activeProvider && data.activeProvider === agent.activeProvider) {
+    // Same provider, session has no activeModel → clear stale override
+    agent.activeModel = null
+    if (agent.provider) {
+      const p = agent.providers?.find((pr) => pr.name === agent.activeProvider)
+      if (p) agent.provider.model = p.model
+    }
   }
   return false
 }
 
-/** Archive current session and reset the session file to empty state */
-export function clearSession(cwd) {
-  try {
-    archiveCurrent(cwd)
-    const p = sessionPath(cwd)
-    writeSessionFile(p, { version: 2, cwd, history: [], tasks: [], display: [], goal: null, autoApprove: false, advisor: null, pendingReminders: [], sessionStart: null })
-  } catch {
-    // Can't clear, oh well — next save will overwrite
+/**
+ * Create a new session slot: allocate a free slot number,
+ * write an empty session, and mark it as the active slot.
+ * Evicts the oldest slot if MAX_SLOTS is reached.
+ */
+export function newSession(cwd) {
+  const m = loadManifest(cwd)
+  // Ensure active is set (migrate if needed)
+  if (!m.active) ensureActive(cwd, m)
+
+  let slot
+  const entries = Object.entries(m.slots).filter(([n]) => /^\d+$/.test(n))
+  if (entries.length < MAX_SLOTS) {
+    slot = 1
+    while (m.slots[slot]) slot++
+  } else {
+    // Full — evict oldest (but never evict the currently active slot)
+    const candidates = entries.filter(([n]) => Number(n) !== m.active)
+    if (candidates.length === 0) {
+      // Should not happen with MAX_SLOTS >= 2 — manifest corruption or all slots are active
+      console.error(`[session] newSession: all ${entries.length} slots are active, cannot evict. Overwriting oldest non-active slot skipped; reusing slot 1.`)
+      slot = 1
+    } else {
+      slot = Number(candidates.sort(slotCmp)[0][0])
+    }
+    // Delete the evicted slot file
+    try { unlinkSync(slotPath(cwd, slot)) } catch {}
   }
+
+  // Write empty session
+  const data = { version: 2, cwd, updatedAt: Date.now(), history: [], tasks: [], display: [], goal: null, autoApprove: false, advisor: null, pendingReminders: [], sessionStart: null }
+  writeSessionFile(slotPath(cwd, slot), data)
+  m.slots[slot] = slotDigest(data)
+  m.active = slot
+  saveManifest(cwd, m)
+  return slot
 }

package/src/skills.mjs

@@ -11,6 +11,7 @@
 
 import { readFile, readdir, stat } from "node:fs/promises"
 import { join } from "node:path"
+import { homedir } from "node:os"
 
 /** Valid skill name pattern (alphanumeric + hyphens/underscores) */
 const NAME_RE = /^[a-zA-Z0-9_-]+$/
@@ -42,13 +43,12 @@ async function tryReadSkill(dir, name, filePath) {
 }
 
 /**
- * Scan .thincoder/skills/ directory, return skill list.
+ * Scan a single skills directory, return skill list.
  * Supports flat .md files and subdirectories with SKILL.md inside.
  * Each skill: { name, path, description } — name derived from filename or directory.
  * Returns empty array if directory is missing or empty.
  */
-export async function loadSkills(cwd) {
-  const dir = join(cwd, ".thincoder", "skills")
+async function loadSkillsFromDir(dir) {
   let entries
   try {
     entries = await readdir(dir, { withFileTypes: true })
@@ -79,6 +79,31 @@ export async function loadSkills(cwd) {
   return skills
 }
 
+/**
+ * Scan both project-level and user-level skills directories.
+ * Project-level skills (cwd/.thincoder/skills/) take priority over user-level (~/.thincoder/skills/).
+ * Returns merged skill list with project-level skills first.
+ */
+export async function loadSkills(cwd) {
+  const projectDir = join(cwd, ".thincoder", "skills")
+  const userDir = join(homedir(), ".thincoder", "skills")
+  
+  // Load project-level skills first (higher priority)
+  const projectSkills = await loadSkillsFromDir(projectDir)
+  const added = new Set(projectSkills.map(s => s.name))
+  
+  // Load user-level skills, skipping duplicates
+  const userSkills = await loadSkillsFromDir(userDir)
+  for (const skill of userSkills) {
+    if (!added.has(skill.name)) {
+      projectSkills.push(skill)
+      added.add(skill.name)
+    }
+  }
+  
+  return projectSkills
+}
+
 /**
  * Generate skill listing text for system prompt injection.
  * At most 3 (small footprint); overflow marked "... and N more".
@@ -94,23 +119,31 @@ export function formatSkillListing(skills) {
 
 /**
  * Read the full content of a specific skill file.
- * Tries subdirectory format (name/SKILL.md) first, then flat format (name.md).
+ * Tries project-level directory first, then user-level directory.
+ * For each directory, tries subdirectory format (name/SKILL.md) first, then flat format (name.md).
  * Returns text, or null if not found.
  */
 export async function readSkill(cwd, name) {
   if (!NAME_RE.test(name)) return null
 
-  // Try subdirectory format: name/SKILL.md
-  try {
-    const p = join(cwd, ".thincoder", "skills", name, "SKILL.md")
-    return await readFile(p, "utf8")
-  } catch { /* not found, try flat */ }
+  const dirs = [
+    join(cwd, ".thincoder", "skills"),
+    join(homedir(), ".thincoder", "skills")
+  ]
 
-  // Fallback to flat format: name.md
-  try {
-    const p = join(cwd, ".thincoder", "skills", `${name}.md`)
-    return await readFile(p, "utf8")
-  } catch {
-    return null
+  for (const baseDir of dirs) {
+    // Try subdirectory format: name/SKILL.md
+    try {
+      const p = join(baseDir, name, "SKILL.md")
+      return await readFile(p, "utf8")
+    } catch { /* not found, try flat */ }
+
+    // Fallback to flat format: name.md
+    try {
+      const p = join(baseDir, `${name}.md`)
+      return await readFile(p, "utf8")
+    } catch { /* not found, try next directory */ }
   }
+  
+  return null
 }

package/src/tools/apply_patch.md

@@ -8,4 +8,4 @@ Notes:
 - Hunks are located by their context/removed lines, not line numbers — but the context must match the file EXACTLY. Read the files first and generate the patch from actual content
 - If a hunk's context matches multiple locations it is rejected — add more surrounding context lines
 - Deleting files is not supported — use the delete tool
-- For single-file small edits, edit is simpler; for full rewrites, write is simpler
+- For single-file edits, edit is simpler; for full rewrites, write is simpler

package/src/tools/codemode.mjs

@@ -24,7 +24,7 @@
 import { Script, createContext } from "node:vm"
 import { readFileSync, writeFileSync, existsSync, mkdirSync, statSync, readdirSync } from "node:fs"
 import { join, dirname, relative, resolve } from "node:path"
-import { globToRegex, normalizeEOL, isPrivateHost } from "./shared.mjs"
+import { DESC, globToRegex, normalizeEOL, isPrivateHost } from "./shared.mjs"
 
 const MAX_OUTPUT = 50_000
 const MAX_SCRIPT = 50_000
@@ -53,9 +53,7 @@ async function sandboxFetch(url) {
 
 export const codeModeTool = {
   name: "execute",
-  description:
-    "Execute sandboxed JavaScript code. Use this to compose multiple file operations into one call — " +
-    "read, write, glob, grep, and log results. No network or system access. Max 30s timeout, 50KB output.",
+  description: DESC("execute"),
   parameters: {
     type: "object",
     properties: {
@@ -96,6 +94,11 @@ export const codeModeTool = {
       return abs
     }
 
+    // Block dynamic imports: check for import() syntax before execution
+    if (/\bimport\s*\(/.test(code)) {
+      return "Error: dynamic import() is not allowed in CodeMode sandbox. Use the provided readFile/writeFile/glob/grep/fetch functions instead."
+    }
+
     const sandbox = createContext({
       readFile: (p) => {
         const abs = safePath(p)
@@ -149,6 +152,9 @@ export const codeModeTool = {
         }
       },
       fetch: sandboxFetch,
+      // Block process and require access
+      require: () => { throw new Error("require() is not available in CodeMode sandbox") },
+      process: undefined,
     })
 
     try {

package/src/tools/delete.md

@@ -2,6 +2,7 @@ Delete a file. Use when the agent created a temporary or junk file that should b
 
 Parameters:
 - path (required): File path, relative to cwd or absolute
+- force: Allow deleting git-tracked files (default false)
 
 Notes:
 - Untracked or non-git files are deleted immediately

package/src/tools/edit.md

@@ -15,6 +15,6 @@ Parameters:
 - replace_all: Replace all occurrences instead of just one (default false)
 
 Notes:
-- Prefer this over write for targeted edits — it's safer and keeps diffs small
+- Prefer this over write for targeted edits — it's safer and keeps changes targeted
 - If old_string matches zero times: error. If it matches multiple times without replace_all: error — add more surrounding context to make it unique
 - Never fabricate the old_string — copy it verbatim from the actual file using read first

package/src/tools/execute.md

@@ -0,0 +1,5 @@
+Execute sandboxed JavaScript code. Use this to compose multiple file operations into one call — read, write, glob, grep, and log results. No network or system access. Max 30s timeout, 50KB output.
+
+Parameters:
+- code (required): JavaScript code to execute in the sandbox. Use provided functions: readFile(path), writeFile(path, content), glob(pattern), grep(pattern, file), log(...args).
+- timeoutMs: Timeout in milliseconds (default 30000, max 60000)