@jkwd/inbase 0.1.3 → 0.1.4

package/apps/explorer/scripts/open-editor.d.ts

@@ -0,0 +1,6 @@
+export function editorFileUri(filePath: string): string
+export function defaultCursorUserDataDir(): string
+export function discoverCursorUserDataDirs(): string[]
+export function openFoldersFromStorage(storage: unknown): string[]
+export function cursorUserDataDirForFile(filePath: string): string | null
+export function openInEditor(filePath: string): boolean

package/apps/explorer/scripts/open-editor.mjs

@@ -0,0 +1,219 @@
+import { spawnSync } from 'node:child_process'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+export function editorFileUri(filePath) {
+  return `vscode://file${encodeURI(filePath)}`
+}
+
+function which(command) {
+  const result = spawnSync('which', [command], { encoding: 'utf8' })
+  if (result.error || result.status !== 0) return null
+  return result.stdout.trim().split('\n')[0] || null
+}
+
+export function defaultCursorUserDataDir() {
+  if (process.platform === 'darwin') {
+    return path.join(os.homedir(), 'Library/Application Support/Cursor')
+  }
+  if (process.platform === 'win32') {
+    return path.join(os.homedir(), 'AppData/Roaming/Cursor')
+  }
+  return path.join(os.homedir(), '.config/Cursor')
+}
+
+function expandUser(value) {
+  if (!value) return null
+  const trimmed = String(value).trim().replace(/^['"]|['"]$/g, '')
+  if (!trimmed) return null
+  if (trimmed.startsWith('~')) {
+    return path.resolve(os.homedir() + trimmed.slice(1))
+  }
+  return path.resolve(trimmed)
+}
+
+function isCursorUserDataDir(dir) {
+  try {
+    if (fs.existsSync(path.join(dir, 'User/globalStorage/storage.json'))) return true
+    return fs.readdirSync(dir).some((name) => name.endsWith('-main.sock'))
+  } catch {
+    return false
+  }
+}
+
+function userDataDirFromHook(hook = process.env.VSCODE_IPC_HOOK) {
+  if (!hook || !hook.endsWith('.sock')) return null
+  const dir = path.dirname(hook)
+  return isCursorUserDataDir(dir) ? dir : null
+}
+
+function userDataDirsFromProcessList() {
+  const result = spawnSync('ps', ['-ax', '-o', 'command='], { encoding: 'utf8' })
+  if (result.error || result.status !== 0) return []
+  const dirs = []
+  for (const line of result.stdout.split('\n')) {
+    const match = line.match(/--user-data-dir(?:=|\s+)(\S+)/)
+    if (!match) continue
+    const dir = expandUser(match[1])
+    if (dir && isCursorUserDataDir(dir)) dirs.push(dir)
+  }
+  return dirs
+}
+
+function profileDirsInHome() {
+  let names = []
+  try {
+    names = fs.readdirSync(os.homedir())
+  } catch {
+    return []
+  }
+  return names
+    .filter((name) => name.startsWith('cursor-profile'))
+    .map((name) => path.join(os.homedir(), name))
+    .filter(isCursorUserDataDir)
+}
+
+export function discoverCursorUserDataDirs() {
+  const dirs = new Set()
+  const explicit = expandUser(
+    process.env.INBASE_CURSOR_USER_DATA_DIR || process.env.CURSOR_USER_DATA_DIR,
+  )
+  if (explicit && isCursorUserDataDir(explicit)) dirs.add(explicit)
+  const hookDir = userDataDirFromHook()
+  if (hookDir) dirs.add(hookDir)
+  const def = defaultCursorUserDataDir()
+  if (isCursorUserDataDir(def)) dirs.add(def)
+  for (const dir of profileDirsInHome()) dirs.add(dir)
+  for (const dir of userDataDirsFromProcessList()) dirs.add(dir)
+  return [...dirs]
+}
+
+function folderPathFromUri(value) {
+  if (typeof value !== 'string' || !value) return null
+  try {
+    return value.startsWith('file:') ? fileURLToPath(value) : path.resolve(value)
+  } catch {
+    return null
+  }
+}
+
+function fileIsInside(folder, filePath) {
+  const root = path.resolve(folder)
+  const file = path.resolve(filePath)
+  return file === root || file.startsWith(`${root}${path.sep}`)
+}
+
+export function openFoldersFromStorage(storage) {
+  const state = storage?.windowsState
+  if (!state || typeof state !== 'object') return []
+  const windows = [
+    state.lastActiveWindow,
+    ...(Array.isArray(state.openedWindows) ? state.openedWindows : []),
+  ]
+  const folders = []
+  for (const window of windows) {
+    const folder = folderPathFromUri(window?.folder)
+    if (folder) folders.push(folder)
+  }
+  return folders
+}
+
+function readOpenFolders(userDataDir) {
+  const file = path.join(userDataDir, 'User/globalStorage/storage.json')
+  try {
+    return openFoldersFromStorage(JSON.parse(fs.readFileSync(file, 'utf8')))
+  } catch {
+    return []
+  }
+}
+
+function lastActiveFolder(userDataDir) {
+  const file = path.join(userDataDir, 'User/globalStorage/storage.json')
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8'))
+    return folderPathFromUri(parsed?.windowsState?.lastActiveWindow?.folder)
+  } catch {
+    return null
+  }
+}
+
+export function cursorUserDataDirForFile(filePath) {
+  const explicit = expandUser(
+    process.env.INBASE_CURSOR_USER_DATA_DIR || process.env.CURSOR_USER_DATA_DIR,
+  )
+  if (explicit && isCursorUserDataDir(explicit)) return explicit
+
+  const hookDir = userDataDirFromHook()
+  let best = null
+  let bestScore = 0
+  for (const dir of discoverCursorUserDataDirs()) {
+    const folders = readOpenFolders(dir)
+    if (!folders.some((folder) => fileIsInside(folder, filePath))) continue
+    let score = 1
+    if (hookDir && path.resolve(hookDir) === path.resolve(dir)) score += 2
+    const last = lastActiveFolder(dir)
+    if (last && fileIsInside(last, filePath)) score += 2
+    if (score > bestScore) {
+      best = dir
+      bestScore = score
+    }
+  }
+  return best ?? hookDir
+}
+
+function cursorCliPaths() {
+  const home = os.homedir()
+  const fromEnv =
+    process.env.CURSOR_CLI && fs.existsSync(process.env.CURSOR_CLI)
+      ? process.env.CURSOR_CLI
+      : null
+  return [
+    fromEnv,
+    which('cursor'),
+    '/Applications/Cursor.app/Contents/Resources/app/bin/cursor',
+    path.join(home, '.local/bin/cursor'),
+    '/usr/local/bin/cursor',
+    '/opt/homebrew/bin/cursor',
+  ].filter((candidate, index, list) => {
+    if (!candidate || typeof candidate !== 'string') return false
+    return list.indexOf(candidate) === index
+  })
+}
+
+function editorEnv() {
+  const env = { ...process.env }
+  delete env.ELECTRON_RUN_AS_NODE
+  delete env.ELECTRON_NO_ASAR
+  delete env.CURSOR_AGENT
+  // A second Cursor instance uses its own sockets. Inherited hooks from
+  // another profile would send --goto to the wrong window.
+  delete env.VSCODE_IPC_HOOK
+  delete env.VSCODE_IPC_HOOK_CLI
+  return env
+}
+
+function runEditor(command, args) {
+  if (command.includes(path.sep) && !fs.existsSync(command)) return false
+  const result = spawnSync(command, args, {
+    stdio: 'ignore',
+    env: editorEnv(),
+  })
+  return !result.error && result.status === 0
+}
+
+export function openInEditor(filePath) {
+  const userDataDir = cursorUserDataDirForFile(filePath)
+  const goto = ['--goto', `${filePath}:1`]
+  if (userDataDir) {
+    goto.unshift('--user-data-dir', userDataDir)
+  }
+  for (const command of cursorCliPaths()) {
+    if (runEditor(command, goto)) return true
+  }
+
+  const code = which('code')
+  if (code && runEditor(code, goto)) return true
+  return false
+}

package/apps/explorer/scripts/session-store.d.ts

@@ -119,6 +119,36 @@ export function sessionIntent(
   knownFileIds?: string[],
   selectedDiffId?: string,
 ): Record<string, unknown> | null
+export function resolveTargetFile(
+  targetRoot: string,
+  fileId: string,
+): { id: string; absolute: string }
+export function captureBaseline(
+  dataDir: string,
+  sessionId: string,
+  targetRoot: string,
+  fileIds?: string[],
+): { files: Record<string, { existed: boolean }> }
+export function restoreBaseline(
+  dataDir: string,
+  sessionId: string,
+  targetRoot: string,
+): void
+export function materializeDiff(
+  dataDir: string,
+  targetRoot: string,
+  sessionId: string,
+  diffId?: string | null,
+): DiffManifest
+export function inspectTargetFile(
+  dataDir: string,
+  targetRoot: string,
+  input?: {
+    sessionId?: string | null
+    diffId?: string | null
+    fileId?: string | null
+  },
+): string | null
 export function appendDiff(
   dataDir: string,
   targetRoot: string,
@@ -142,7 +172,7 @@ export function requestReplan(
 export function stopSession(
   dataDir: string,
   sessionId: string,
-  diffId?: string,
+  targetRoot?: string | null,
 ): null
 export function decideDiff(
   dataDir: string,

package/apps/explorer/scripts/session-store.mjs

@@ -44,9 +44,28 @@ export function sessionPaths(dataDir, sessionId) {
     diffs: path.join(root, 'diffs'),
     manifest: path.join(root, 'manifest.json'),
     blueprint: path.join(root, 'blueprint.json'),
+    baseline: path.join(root, 'baseline.json'),
+    baselineFiles: path.join(root, 'baseline'),
   }
 }
 
+export function resolveTargetFile(targetRoot, fileId) {
+  if (typeof fileId !== 'string' || fileId.trim() === '') {
+    throw new Error('fileId is required')
+  }
+  const normalized = fileId.trim().replaceAll('\\', '/').replace(/^\/+/, '')
+  if (!normalized || normalized === '.' || normalized.includes('..')) {
+    throw new Error(`Invalid file id ${fileId}`)
+  }
+  const root = path.resolve(targetRoot)
+  const absolute = path.resolve(root, normalized)
+  const prefix = root.endsWith(path.sep) ? root : `${root}${path.sep}`
+  if (absolute !== root && !absolute.startsWith(prefix)) {
+    throw new Error(`Invalid file id ${fileId}`)
+  }
+  return { id: normalized, absolute }
+}
+
 export function readActiveSession(dataDir) {
   const value = readJson(path.join(dataDir, 'active-session.json'), null)
   return value?.sessionId ? assertSessionId(value.sessionId) : null
@@ -305,10 +324,105 @@ export function sessionIntent(dataDir, sessionId, knownFileIds = [], selectedDif
   }
 }
 
-function withVirtualTarget(targetRoot, patches, action) {
+function emptyBaseline() {
+  return { files: {} }
+}
+
+function readBaseline(dataDir, sessionId) {
+  const { baseline } = sessionPaths(dataDir, sessionId)
+  const value = readJson(baseline, emptyBaseline())
+  return {
+    files:
+      value?.files && typeof value.files === 'object' && !Array.isArray(value.files)
+        ? value.files
+        : {},
+  }
+}
+
+function writeBaseline(dataDir, sessionId, baseline) {
+  const { baseline: file } = sessionPaths(dataDir, sessionId)
+  atomicWrite(file, `${JSON.stringify({ files: baseline.files ?? {} }, null, 2)}\n`)
+}
+
+function pruneEmptyDirs(targetRoot, filePath) {
+  const root = path.resolve(targetRoot)
+  let current = path.dirname(filePath)
+  while (current.startsWith(`${root}${path.sep}`)) {
+    if (!fs.existsSync(current)) {
+      current = path.dirname(current)
+      continue
+    }
+    if (fs.readdirSync(current).length > 0) break
+    fs.rmdirSync(current)
+    current = path.dirname(current)
+  }
+}
+
+export function captureBaseline(dataDir, sessionId, targetRoot, fileIds = []) {
+  const paths = sessionPaths(dataDir, sessionId)
+  const baseline = readBaseline(dataDir, sessionId)
+  let changed = false
+  for (const fileId of fileIds) {
+    const { id, absolute } = resolveTargetFile(targetRoot, fileId)
+    if (baseline.files[id]) continue
+    const existed = fs.existsSync(absolute) && fs.statSync(absolute).isFile()
+    baseline.files[id] = { existed }
+    if (existed) {
+      const stored = resolveTargetFile(paths.baselineFiles, id).absolute
+      fs.mkdirSync(path.dirname(stored), { recursive: true })
+      fs.copyFileSync(absolute, stored)
+    }
+    changed = true
+  }
+  if (changed) writeBaseline(dataDir, sessionId, baseline)
+  return baseline
+}
+
+export function restoreBaseline(dataDir, sessionId, targetRoot) {
+  const paths = sessionPaths(dataDir, sessionId)
+  const baseline = readBaseline(dataDir, sessionId)
+  for (const [fileId, info] of Object.entries(baseline.files)) {
+    const { absolute } = resolveTargetFile(targetRoot, fileId)
+    if (!info?.existed) {
+      fs.rmSync(absolute, { force: true })
+      pruneEmptyDirs(targetRoot, absolute)
+      continue
+    }
+    const stored = resolveTargetFile(paths.baselineFiles, fileId).absolute
+    fs.mkdirSync(path.dirname(absolute), { recursive: true })
+    fs.copyFileSync(stored, absolute)
+  }
+}
+
+function replayPatches(dataDir, sessionId, targetRoot, entries) {
+  for (const entry of entries) {
+    applyUnifiedPatch(readDiff(dataDir, sessionId, entry), targetRoot)
+  }
+}
+
+function acceptedEntries(manifest) {
+  return manifest.diffs.filter((entry) => entry.status === 'applied')
+}
+
+function liveEntries(manifest, diffId) {
+  return chainThrough(manifest, diffId).filter((entry) => entry.status !== 'rejected')
+}
+
+export function materializeDiff(dataDir, targetRoot, sessionId, diffId) {
+  const manifest = readManifest(dataDir, assertSessionId(sessionId))
+  if (!manifest) throw new Error(`Unknown session ${sessionId}`)
+  const through = diffId || manifest.activeDiffId
+  if (!through) return manifest
+  restoreBaseline(dataDir, sessionId, targetRoot)
+  replayPatches(dataDir, sessionId, targetRoot, liveEntries(manifest, through))
+  return manifest
+}
+
+function withSessionReplay(dataDir, sessionId, targetRoot, patches, action) {
   const temporary = fs.mkdtempSync(path.join(os.tmpdir(), 'visual-coder-chain-'))
   try {
     fs.cpSync(targetRoot, temporary, { recursive: true })
+    restoreBaseline(dataDir, sessionId, temporary)
     for (const patchText of patches) applyUnifiedPatch(patchText, temporary)
     return action(temporary)
   } finally {
@@ -317,10 +431,28 @@ function withVirtualTarget(targetRoot, patches, action) {
 }
 
 export function validateContinuation(dataDir, manifest, targetRoot, patchText) {
-  const prior = unresolvedEntries(manifest).map((entry) =>
-    readDiff(dataDir, manifest.sessionId, entry),
+  const prior = manifest.diffs
+    .filter((entry) => entry.status !== 'rejected')
+    .map((entry) => readDiff(dataDir, manifest.sessionId, entry))
+  withSessionReplay(dataDir, manifest.sessionId, targetRoot, [...prior, patchText], () =>
+    undefined,
   )
-  withVirtualTarget(targetRoot, [...prior, patchText], () => undefined)
+}
+
+export function inspectTargetFile(
+  dataDir,
+  targetRoot,
+  { sessionId, diffId, fileId } = {},
+) {
+  if (sessionId && readManifest(dataDir, sessionId)) {
+    materializeDiff(dataDir, targetRoot, sessionId, diffId)
+  }
+  if (!fileId) return null
+  const { absolute } = resolveTargetFile(targetRoot, fileId)
+  if (!fs.existsSync(absolute) || !fs.statSync(absolute).isFile()) {
+    throw new Error(`File ${fileId} is not on disk`)
+  }
+  return absolute
 }
 
 function planSteps(titles, startAt = 1) {
@@ -555,6 +687,12 @@ export function appendDiff(dataDir, targetRoot, input) {
   }
 
   validateContinuation(dataDir, manifest, targetRoot, input.patchText)
+  captureBaseline(
+    dataDir,
+    sessionId,
+    targetRoot,
+    parseUnifiedPatch(input.patchText).entries.map((entry) => entry.id),
+  )
   if (parent?.status === 'extend') parent.status = 'extended'
 
   const id = String(manifest.diffs.length + 1).padStart(4, '0')
@@ -581,6 +719,7 @@ export function appendDiff(dataDir, targetRoot, input) {
   manifest.workStartedAt = null
   manifest.diffs.push(entry)
   writeManifest(dataDir, manifest)
+  materializeDiff(dataDir, targetRoot, sessionId, id)
   focusSession(dataDir, sessionId)
   return { manifest, entry }
 }
@@ -601,25 +740,7 @@ function pendingActive(manifest, diffId) {
 
 function applyUnresolved(dataDir, targetRoot, manifest, diffId) {
   const unresolved = unresolvedEntries(manifest, diffId)
-  const patches = unresolved.map((entry) =>
-    readDiff(dataDir, manifest.sessionId, entry),
-  )
-  const touched = new Set()
-  for (const patch of patches) {
-    for (const entry of parseUnifiedPatch(patch).entries) touched.add(entry.id)
-  }
-  withVirtualTarget(targetRoot, patches, (virtualRoot) => {
-    for (const id of touched) {
-      const source = path.join(virtualRoot, id)
-      const destination = path.join(targetRoot, id)
-      if (!fs.existsSync(source)) {
-        fs.rmSync(destination, { recursive: true, force: true })
-        continue
-      }
-      fs.mkdirSync(path.dirname(destination), { recursive: true })
-      fs.copyFileSync(source, destination)
-    }
-  })
+  materializeDiff(dataDir, targetRoot, manifest.sessionId, diffId)
   for (const entry of unresolved) {
     entry.status = 'applied'
     entry.decidedAt = new Date().toISOString()
@@ -663,8 +784,14 @@ export function requestReplan(dataDir, sessionId, diffId, instruction) {
   return manifest
 }
 
-export function stopSession(dataDir, sessionId, _diffId) {
-  finalizeFinishedSession(dataDir, sessionId)
+export function stopSession(dataDir, sessionId, targetRoot = null) {
+  const safeId = assertSessionId(sessionId)
+  const manifest = readManifest(dataDir, safeId)
+  if (manifest && targetRoot) {
+    restoreBaseline(dataDir, safeId, targetRoot)
+    replayPatches(dataDir, safeId, targetRoot, acceptedEntries(manifest))
+  }
+  finalizeFinishedSession(dataDir, safeId)
   return null
 }
 
@@ -682,7 +809,7 @@ export function decideDiff(
   if (decision === 'extend') {
     return requestReplan(dataDir, sessionId, diffId, instruction)
   }
-  return stopSession(dataDir, sessionId, diffId)
+  return stopSession(dataDir, sessionId, targetRoot)
 }
 
 export function closeSession(dataDir, sessionId) {

package/apps/explorer/src/App.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
 import { Canvas } from '@react-three/fiber'
-import { emptyIntent, fetchAgentIntent, performAgentAction, persistSessionBlueprint } from './agentIntent'
+import { emptyIntent, fetchAgentIntent, inspectTargetFile, performAgentAction, persistSessionBlueprint } from './agentIntent'
 import { fetchCodebase } from './codebase'
 import {
   layoutWorld,
@@ -163,6 +163,7 @@ function Explorer({
   ])
   const walkPos = useRef<[number, number]>([layout.spawn[0], layout.spawn[2]])
   const [selectedId, setSelectedId] = useState<string | null>(null)
+  const [selectedTick, setSelectedTick] = useState(0)
   const [selectedFolder, setSelectedFolder] = useState<string | null>(null)
   const [aimedRelation, setAimedRelation] = useState<AimedRelation | null>(null)
   const [flyTo, setFlyTo] = useState<FlyTo | null>(null)
@@ -274,7 +275,7 @@ function Explorer({
         browsingHistory.current = false
         lastIntentSig.current = intentSignature(next)
         applyIntent(next)
-        if (action === 'invoke' || action === 'continue') {
+        if (action === 'invoke' || action === 'continue' || action === 'stop') {
           await onRefreshGraph()
         }
       } catch {
@@ -300,6 +301,16 @@ function Explorer({
       try {
         const latest = intent.chain.at(-1)?.id
         browsingHistory.current = diffId !== latest
+        if (intent.sessionId) {
+          try {
+            await inspectTargetFile({
+              sessionId: intent.sessionId,
+              diffId,
+            })
+          } catch {
+            // Still show the historical preview if disk replay failed.
+          }
+        }
         const next = await fetchAgentIntent(diffId)
         lastIntentSig.current = intentSignature(next)
         applyIntent(next)
@@ -307,7 +318,22 @@ function Explorer({
         // Keep the current chain position if navigation failed.
       }
     },
-    [applyIntent, intent.chain],
+    [applyIntent, intent.chain, intent.sessionId],
+  )
+
+  const inspectFile = useCallback(
+    async (fileId: string) => {
+      try {
+        await inspectTargetFile({
+          sessionId: intent.sessionId,
+          diffId: intent.diffId,
+          fileId,
+        })
+      } catch {
+        // Keep the current view if the editor could not open the file.
+      }
+    },
+    [intent.diffId, intent.sessionId],
   )
 
   useEffect(() => {
@@ -566,7 +592,10 @@ function Explorer({
   const selectFile = useCallback(
     (fileId: string | null) => {
       setSelectedId(fileId)
-      if (fileId) setSelectedFolder(null)
+      if (fileId) {
+        setSelectedFolder(null)
+        setSelectedTick((tick) => tick + 1)
+      }
       if (fileId && intent.creationMode) document.exitPointerLock()
     },
     [intent.creationMode],
@@ -904,6 +933,7 @@ function Explorer({
         mode={mode}
         locked={locked}
         selectedId={selectedId}
+        selectedTick={selectedTick}
         selectedFolder={selectedFolder}
         aimedRelation={aimedRelation}
         currentFolder={currentFolder}
@@ -935,6 +965,7 @@ function Explorer({
         onRemoveBlueprintImport={removeBlueprintImport}
         onMapAddFile={placeBlockOnFolder}
         onMapAddFolder={placeIslandOnFolder}
+        onInspectFile={inspectFile}
       />
     </>
   )

package/apps/explorer/src/agentIntent.ts

@@ -180,3 +180,24 @@ export function persistSessionBlueprint(
     // Keep local drafts if the session handshake is no longer open.
   })
 }
+
+export async function inspectTargetFile(payload: {
+  sessionId?: string | null
+  diffId?: string | null
+  fileId?: string
+}) {
+  const response = await fetch('/api/inspect-file', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(payload),
+  })
+  if (!response.ok) {
+    const detail = await response.text()
+    throw new Error(detail || 'Could not inspect file')
+  }
+  return (await response.json()) as {
+    path: string | null
+    uri: string | null
+    opened: boolean
+  }
+}

package/apps/explorer/src/index.css

@@ -22,6 +22,7 @@ body,
   position: absolute;
   inset: 0;
   z-index: 0;
+  background: #000;
 }
 
 * {
@@ -566,6 +567,11 @@ button {
   word-break: break-all;
 }
 
+.hud-inspect {
+  margin: 10px 0 0;
+  width: 100%;
+}
+
 .hud-panel ul {
   margin: 8px 0 0;
   padding-left: 18px;
@@ -599,6 +605,21 @@ button {
   border-color: #8a4a4a;
 }
 
+.hud-item-inspect {
+  flex: none;
+  padding: 2px 6px;
+  color: #d7eef8;
+  background: transparent;
+  border: 1px solid #3a4250;
+  cursor: pointer;
+  font-size: 11px;
+}
+
+.hud-item-inspect:hover,
+.hud-item-inspect:focus-visible {
+  border-color: #9ad8ff;
+}
+
 .hud-add-row {
   display: flex;
   gap: 6px;

package/apps/explorer/src/scene/MapView.tsx

@@ -66,8 +66,14 @@ export function MapView({
     const element = gl.domElement
     element.style.cursor = 'grab'
 
+    const isWalkClick = (event: PointerEvent | MouseEvent) =>
+      event.shiftKey || event.ctrlKey || event.metaKey
+
+    const isWalkButton = (event: PointerEvent) =>
+      event.button === 0 || (event.ctrlKey && event.button === 2)
+
     const onDown = (event: PointerEvent) => {
-      if (event.button !== 0) return
+      if (!isWalkButton(event)) return
       drag.current = { x: event.clientX, y: event.clientY, moved: false, active: true }
       element.style.cursor = 'grabbing'
     }
@@ -93,20 +99,31 @@ export function MapView({
       return { raycaster, relationHit, fileHit }
     }
 
-    const landAtPointer = (clientX: number, clientY: number) => {
+    const landAt = (x: number, z: number) => {
+      const lock = element.requestPointerLock()
+      if (lock && typeof lock.catch === 'function') {
+        void lock.catch(() => {})
+      }
+      onLand(x, z)
+    }
+
+    const landAtPointer = (clientX: number, clientY: number, allowIsland: boolean) => {
       const pick = pickAt(clientX, clientY)
       if (!pick) return false
       const { raycaster, relationHit, fileHit } = pick
-      if (relationHit || fileHit) return false
 
       const hit = new THREE.Vector3()
       const plane = new THREE.Plane(new THREE.Vector3(0, 1, 0), 0)
       if (!raycaster.ray.intersectPlane(plane, hit)) return false
-      const lock = element.requestPointerLock()
-      if (lock && typeof lock.catch === 'function') {
-        void lock.catch(() => {})
+
+      const folder = folderAt(hit.x, hit.z, layout)
+      if (allowIsland && folder) {
+        landAt(hit.x, hit.z)
+        return true
       }
-      onLand(hit.x, hit.z)
+      if (relationHit || fileHit) return false
+
+      landAt(hit.x, hit.z)
       return true
     }
 
@@ -114,9 +131,11 @@ export function MapView({
       element.style.cursor = 'grab'
       const startedOnCanvas = drag.current.active
       drag.current.active = false
-      if (!startedOnCanvas || event.button !== 0 || drag.current.moved) return
+      if (!startedOnCanvas || !isWalkButton(event) || drag.current.moved) return
 
-      if (event.shiftKey && landAtPointer(event.clientX, event.clientY)) return
+      if (isWalkClick(event) && landAtPointer(event.clientX, event.clientY, true)) {
+        return
+      }
 
       const pick = pickAt(event.clientX, event.clientY)
       if (!pick) return
@@ -149,14 +168,20 @@ export function MapView({
       onSelectFolder(null)
     }
 
+    const onContextMenu = (event: MouseEvent) => {
+      if (event.ctrlKey) event.preventDefault()
+    }
+
     element.addEventListener('pointerdown', onDown)
     window.addEventListener('pointermove', onMove)
     window.addEventListener('pointerup', onUp)
+    element.addEventListener('contextmenu', onContextMenu)
     return () => {
       element.style.cursor = ''
       element.removeEventListener('pointerdown', onDown)
       window.removeEventListener('pointermove', onMove)
       window.removeEventListener('pointerup', onUp)
+      element.removeEventListener('contextmenu', onContextMenu)
     }
   }, [
     camera,

package/apps/explorer/src/scene/World.tsx

@@ -8,8 +8,8 @@ import { SelectionController } from './SelectionController'
 import { UserContextTracker } from './UserContextTracker'
 import { BlockPlacer } from './BlockPlacer'
 import { IslandPlacer } from './IslandPlacer'
-import { folderOfFile, filesImporting, worldBounds } from '../layout'
-import { EDITOR_GREY } from '../theme'
+import { folderOfFile, filesImporting } from '../layout'
+import { WORLD_VOID } from '../theme'
 import type { ChangeKind } from '../theme'
 import type {
   CodebaseGraph,
@@ -159,28 +159,16 @@ export function World({
     return null
   }
 
-  const bounds = worldBounds(layout)
-  const groundPad = 120
-  const groundWidth = Math.max(bounds.width + groundPad * 2, 400)
-  const groundDepth = Math.max(bounds.depth + groundPad * 2, 400)
-
   return (
     <>
-      <color attach="background" args={[EDITOR_GREY.chrome]} />
-      {!mapping && <fog attach="fog" args={[EDITOR_GREY.chrome, 38, 160]} />}
+      <color attach="background" args={[WORLD_VOID]} />
+      {!mapping && <fog attach="fog" args={[WORLD_VOID, 38, 160]} />}
       <hemisphereLight args={['#d7e2ee', '#2a3038', mapping ? 1.1 : 0.85]} />
       <directionalLight
         position={mapping ? [8, 60, 8] : [12, 22, 8]}
         intensity={mapping ? 1.35 : 0.55}
       />
       <ambientLight intensity={mapping ? 0.7 : 0.42} />
-      <mesh
-        rotation={[-Math.PI / 2, 0, 0]}
-        position={[bounds.cx, -0.06, bounds.cz]}
-      >
-        <planeGeometry args={[groundWidth, groundDepth]} />
-        <meshBasicMaterial color={EDITOR_GREY.chrome} />
-      </mesh>
       <MapView
         layout={layout}
         enabled={mapping}

package/apps/explorer/src/theme.ts

@@ -25,6 +25,9 @@ export const EDITOR_GREY = {
   surface: '#272c36',
 }
 
+/** Infinite map/walk backdrop. Keep distinct from chrome HUD greys. */
+export const WORLD_VOID = '#000000'
+
 export type ChangeKind = 'add' | 'edit' | 'remove'
 
 export const CHANGE_HIGHLIGHT: Record<

package/apps/explorer/src/ui/HUD.tsx

@@ -128,6 +128,7 @@ type HUDProps = {
   mode: ViewMode
   locked: boolean
   selectedId: string | null
+  selectedTick?: number
   selectedFolder?: string | null
   aimedRelation: AimedRelation | null
   currentFolder: string
@@ -162,6 +163,7 @@ type HUDProps = {
   ) => void
   onMapAddFile?: (folderPath: string) => void
   onMapAddFolder?: (folderPath: string) => void
+  onInspectFile?: (fileId: string) => void
 }
 
 export function HUD({
@@ -169,6 +171,7 @@ export function HUD({
   mode,
   locked,
   selectedId,
+  selectedTick = 0,
   selectedFolder = null,
   aimedRelation,
   currentFolder,
@@ -196,6 +199,7 @@ export function HUD({
   onRemoveBlueprintImport,
   onMapAddFile,
   onMapAddFolder,
+  onInspectFile,
 }: HUDProps) {
   const selected = graph.files.find((file) => file.id === selectedId)
   const selectedFolderNode = graph.folders.find(
@@ -299,6 +303,11 @@ export function HUD({
   const canRunNext =
     Boolean(nextStep) && (planReady || pending) && !working
   const canComplete = pending && lastStep
+  const canInspectFile = (fileId: string, userCreated = false) =>
+    Boolean(onInspectFile) &&
+    !fileId.startsWith('draft:') &&
+    !(previewing && (intent.deletes ?? []).includes(fileId)) &&
+    (!userCreated || (intent.creates ?? []).includes(fileId))
   const panelDone =
     intent.status === 'finished' ||
     intent.status === 'approved' ||
@@ -332,8 +341,8 @@ export function HUD({
   }, [selectedId, selectedFolder])
 
   useEffect(() => {
-    if (sessionMode && selectedId) setInfoVisible(true)
-  }, [selectedId, sessionMode])
+    if (selectedId) setInfoVisible(true)
+  }, [selectedId, selectedTick])
 
   useEffect(() => {
     if (selectedFolder) setInfoVisible(true)
@@ -402,7 +411,7 @@ export function HUD({
                   , <kbd>Space</kbd> place a file, <kbd>B</kbd> place an island
                 </>
               ) : null}
-              , click a block for imports.
+              , click a block for info.
             </p>
           </div>
         </div>
@@ -757,6 +766,15 @@ export function HUD({
           <p>
             {selected.lines} lines · {selected.language}
           </p>
+          {canInspectFile(selected.id, selected.userCreated) && (
+            <button
+              className="hud-button hud-inspect"
+              type="button"
+              onClick={() => onInspectFile?.(selected.id)}
+            >
+              Inspect file
+            </button>
+          )}
           {selectedClasses.length > 0 && (
             <>
               <div className="hud-section-title">Classes</div>
@@ -955,7 +973,18 @@ export function HUD({
           ) : (
             <ul>
               {folderFiles.map((file) => (
-                <li key={file.id}>{file.path || file.id}</li>
+                <li key={file.id}>
+                  <span>{file.path || file.id}</span>
+                  {canInspectFile(file.id, file.userCreated) && (
+                    <button
+                      className="hud-item-inspect"
+                      type="button"
+                      onClick={() => onInspectFile?.(file.id)}
+                    >
+                      Inspect
+                    </button>
+                  )}
+                </li>
               ))}
             </ul>
           )}
@@ -988,11 +1017,7 @@ export function HUD({
             <>
               <span>Scroll zoom</span>
               <span>Drag pan</span>
-              <span>
-                {sessionMode
-                  ? 'Click a block for info'
-                  : 'Click a block for relations'}
-              </span>
+              <span>Click a block for info</span>
               <span>Click an island for its files</span>
               {creatingBlueprint && (
                 <>
@@ -1001,19 +1026,11 @@ export function HUD({
                 </>
               )}
               <span>Click a line to fly there</span>
-              <span>Shift-click ground to walk</span>
+              <span>Ctrl-click an island to walk</span>
               {selected?.userCreated && creatingBlueprint && (
                 <span>Backspace delete</span>
               )}
-              <span>
-                {sessionMode
-                  ? infoVisible
-                    ? 'I hide info'
-                    : 'Click a block for info'
-                  : infoVisible
-                    ? 'I hide info'
-                    : 'I show info'}
-              </span>
+              <span>{infoVisible ? 'I hide info' : 'I show info'}</span>
               {infoVisible && <span>↑↓ scroll info</span>}
               <span>
                 {importedBy ? 'K show imports' : 'K show imported by'}
@@ -1034,21 +1051,9 @@ export function HUD({
               {selected?.userCreated && creatingBlueprint && (
                 <span>Backspace delete</span>
               )}
-              <span>
-                {sessionMode
-                  ? 'Click a block for info'
-                  : 'Click block for relations'}
-              </span>
+              <span>Click a block for info</span>
               <span>Aim a line to fly</span>
-              <span>
-                {sessionMode
-                  ? infoVisible
-                    ? 'I hide info'
-                    : 'Click a block for info'
-                  : infoVisible
-                    ? 'I hide info'
-                    : 'I show info'}
-              </span>
+              <span>{infoVisible ? 'I hide info' : 'I show info'}</span>
               {infoVisible && <span>↑↓ scroll info</span>}
               <span>
                 {importedBy ? 'K show imports' : 'K show imported by'}

package/apps/explorer/vite.config.ts

@@ -7,9 +7,11 @@ import { fileURLToPath } from 'node:url'
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { emptyIntent } from './scripts/patch-lib.mjs'
 import { dataDir, targetRoot } from './scripts/target-config.mjs'
+import { editorFileUri, openInEditor } from './scripts/open-editor.mjs'
 import {
   answerBlueprint,
   continueDiff,
+  inspectTargetFile,
   invokeStep,
   readActiveSession,
   requestReplan,
@@ -105,10 +107,46 @@ function jsonFilePlugin(): Plugin {
 
         next()
       })
+
+      server.middlewares.use('/api/inspect-file', (req, res, next) => {
+        if (req.method === 'POST') {
+          void inspectFile(req, res)
+          return
+        }
+        next()
+      })
     },
   }
 }
 
+async function inspectFile(req: IncomingMessage, res: ServerResponse) {
+  try {
+    const body = JSON.parse(await readBody(req)) as {
+      sessionId?: string
+      diffId?: string
+      fileId?: string
+    }
+    const filePath = inspectTargetFile(dataDir, targetRoot, {
+      sessionId: body.sessionId,
+      diffId: body.diffId,
+      fileId: body.fileId,
+    })
+    if (!filePath) {
+      sendJson(res, 200, { path: null, uri: null, opened: false })
+      return
+    }
+    const opened = openInEditor(filePath)
+    sendJson(res, 200, {
+      path: filePath,
+      uri: editorFileUri(filePath),
+      opened,
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'invalid request'
+    sendJson(res, 400, { error: message })
+  }
+}
+
 async function decideIntent(req: IncomingMessage, res: ServerResponse) {
   try {
     const body = JSON.parse(await readBody(req)) as {
@@ -209,7 +247,7 @@ async function decideIntent(req: IncomingMessage, res: ServerResponse) {
         addedImports: body.addedImports,
       })
     } else {
-      stopSession(dataDir, body.sessionId, body.diffId)
+      stopSession(dataDir, body.sessionId, targetRoot)
     }
     const next = sessionIntent(dataDir, body.sessionId, knownFileIds())
     sendJson(res, 200, next ?? { ...emptyIntent })

package/bin/session.mjs

@@ -201,7 +201,7 @@ export async function proposePatch(args) {
 
   if (clear) {
     if (!sessionId) usage('propose-patch', '--session <cursor-chat-id> --clear')
-    store.stopSession(config.dataDir, sessionId)
+    store.stopSession(config.dataDir, sessionId, config.targetRoot)
     console.log(
       `Cleared session ${sessionId}; stored diffs and blueprint drafts were removed.`,
     )

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jkwd/inbase",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "A first-person 3D map of a codebase, with a visual coding workflow for Cursor.",
   "repository": {
     "type": "git",
@@ -29,6 +29,8 @@
     "apps/explorer/src/scene",
     "apps/explorer/src/ui",
     "apps/explorer/scripts/js-source.mjs",
+    "apps/explorer/scripts/open-editor.d.ts",
+    "apps/explorer/scripts/open-editor.mjs",
     "apps/explorer/scripts/patch-lib.d.ts",
     "apps/explorer/scripts/patch-lib.mjs",
     "apps/explorer/scripts/scan-target.mjs",