refactor(mothership): sim-side quality pass + dead-code sweep from the parity hill-climb

Quality (25 verified findings from the review pass): the embedded CLI's
soft-fail exit code rode the process-global exitCode two parallel
invocations raced on — it now rides the EmbedContext (setSoftExitCode
seam, global fallback for the standalone CLI). Model-authored wire params
lose their bare as-casts for typeof guards (run segments, run-tool params,
output-file declarations, function-execute refs via one refField helper);
the six copy-pasted cancel-settlement blocks in the tool executor fold
into one settleCancelled; five error-completion literals into one builder;
three title-casing humanizers into one; the sandbox image cache moves from
a hand-rolled TTL map to lru-cache; sleepWithAbort yields to
interruptibleSleep; plus dead re-exports, a pass-through wrapper, a dead
param, an unreachable busy-spin branch made an invariant, and misc rule
violations (inline sleep/getErrorMessage/truncate, mid-file import,
retired-tool literal).

Dead code (verified-unreferenced, from the Go-era audit): four delegated
use-cases replaced by sim_cli, the file-subagent doc raster pipeline, env
secret-ref resolution, workflow-state prompt formatting, the runtime
stream-schema mirror (sync script trimmed to match), the workflow
checkpoint/revert feature (routes + contracts; table drop deferred), and
five orphaned copilot routes (update-messages, models, credentials,
rename, and the duplicate chat mount — /api/mothership/chat is the live
path). LONG_RUNNING_TOOL_IDS trimmed to the live tool surface with tests
re-anchored. Go-decommission-gated routes (tools/execute, key/byok
validate, inbandOwned) and policy items (steering chain, Go-era replay
titles) deliberately kept — listed in the audit doc for Sid.

Claude-Session: https://claude.ai/code/session_01CgaxNAaeD3taGdghbXn17w

Author: Sg312

apps/sim/app/api/copilot/chat/route.ts

@@ -586,25 +586,6 @@ export const copilotChatStopContract = defineRouteContract({
   response: { mode: 'json', schema: successFlagSchema },
 })
 
-export const copilotChatGetContract = defineRouteContract({
-  method: 'GET',
-  path: '/api/copilot/chat',
-  query: copilotChatGetQuerySchema,
-  response: {
-    mode: 'json',
-    schema: z.union([
-      z.object({
-        success: z.literal(true),
-        chat: copilotChatGetChatSchema,
-      }),
-      z.object({
-        success: z.literal(true),
-        chats: z.array(copilotChatGetListItemSchema),
-      }),
-    ]),
-  },
-})
-
 export const deleteCopilotChatContract = defineRouteContract({
   method: 'DELETE',
   path: '/api/copilot/chat/delete',

apps/sim/lib/api/contracts/copilot.ts

@@ -911,10 +911,11 @@ async function provisionWithinBudget(
 }
 
 async function executeInSandboxWithinBudget(
-  req: SandboxExecutionRequest
+  // The budget wrapper always injects the signal; the required-signal type states that
+  // invariant instead of a cast hiding it.
+  req: SandboxExecutionRequest & { signal: AbortSignal }
 ): Promise<SandboxExecutionResult> {
-  const { code, language } = req
-  const signal = req.signal as AbortSignal
+  const { code, language, signal } = req
   const kind = req.sandboxKind ?? 'code'
   throwIfAborted(signal)
 
@@ -1084,10 +1085,9 @@ export function executeInSandbox(req: SandboxExecutionRequest): Promise<SandboxE
 }
 
 async function executeShellInSandboxWithinBudget(
-  req: SandboxShellExecutionRequest
+  req: SandboxShellExecutionRequest & { signal: AbortSignal }
 ): Promise<SandboxExecutionResult> {
-  const { code, envs } = req
-  const signal = req.signal as AbortSignal
+  const { code, envs, signal } = req
   const kind = req.sandboxKind ?? 'shell'
   throwIfAborted(signal)
 

apps/sim/lib/execution/remote-sandbox/index.ts

@@ -1,5 +1,6 @@
 import { createLogger } from '@sim/logger'
 import { getErrorMessage } from '@sim/utils/errors'
+import { LRUCache } from 'lru-cache'
 import { CodeLanguage } from '@/lib/execution/languages'
 import { classifyInstallOutput, tailBuildLog } from '@/lib/execution/remote-sandbox/build-errors'
 import {
@@ -114,21 +115,13 @@ interface CachedImage {
   errorMessage: string | null
 }
 
-interface CacheEntry {
-  expiresAt: number
-  value: CachedImage
-}
-
 /**
- * Both maps are process-lifetime and keyed by an unbounded space (every spec
- * hash ever executed), so each drops its oldest entry rather than growing for
- * the life of the worker.
+ * Both caches are keyed by an unbounded space (every spec hash ever executed):
+ * `max` is the memory backstop, `ttl` the freshness policy — lru-cache owns
+ * expiry/eviction/ceiling per the caching rule (never hand-roll TTL arithmetic).
  */
-const IMAGE_CACHE_LIMIT = 1000
-const LAST_USED_CACHE_LIMIT = 1000
-
-const imageCache = new Map<string, CacheEntry>()
-const lastUsedWrites = new Map<string, number>()
+const imageCache = new LRUCache<string, CachedImage>({ max: 1000, ttl: IMAGE_TTL_MS })
+const lastUsedWrites = new LRUCache<string, number>({ max: 1000, ttl: LAST_USED_DEBOUNCE_MS })
 
 /**
  * JavaScript packages live outside the default resolution roots, so Node needs
@@ -155,11 +148,9 @@ function envsFor(
  */
 function touchImage(specHash: string, provider: string): void {
   const key = `${provider}:${specHash}`
-  const now = Date.now()
-  const written = lastUsedWrites.get(key)
-  if (written && now - written < LAST_USED_DEBOUNCE_MS) return
-  if (lastUsedWrites.size >= LAST_USED_CACHE_LIMIT) lastUsedWrites.clear()
-  lastUsedWrites.set(key, now)
+  // The TTL IS the debounce: a still-fresh entry means we wrote recently.
+  if (lastUsedWrites.get(key) !== undefined) return
+  lastUsedWrites.set(key, Date.now())
   void sandboxDb()
     .then(({ db, sandboxImage, and, eq }) =>
       db
@@ -381,10 +372,7 @@ async function readImage(
 ): Promise<CachedImage | undefined> {
   const cacheKey = `${providerId}:${specHash}:${materializationGeneration}:${materializationRefPrefix}`
   const cached = imageCache.get(cacheKey)
-  if (cached) {
-    if (cached.expiresAt > Date.now()) return cached.value
-    imageCache.delete(cacheKey)
-  }
+  if (cached !== undefined) return cached
 
   const { db, sandboxImage, and, eq } = await sandboxDb()
   const [image] = await db
@@ -399,13 +387,7 @@ async function readImage(
     .where(and(eq(sandboxImage.provider, providerId), eq(sandboxImage.specHash, specHash)))
     .limit(1)
 
-  if (image?.status === 'ready') {
-    if (imageCache.size >= IMAGE_CACHE_LIMIT) {
-      const oldest = imageCache.keys().next()
-      if (!oldest.done) imageCache.delete(oldest.value)
-    }
-    imageCache.set(cacheKey, { expiresAt: Date.now() + IMAGE_TTL_MS, value: image })
-  }
+  if (image?.status === 'ready') imageCache.set(cacheKey, image)
   return image
 }