helloagents 3.0.38 → 3.1.1

package/scripts/cli-runtime-root.mjs

@@ -1,7 +1,7 @@
 import { copyFileSync, existsSync, mkdtempSync, realpathSync, renameSync } from 'node:fs'
 import { dirname, join, resolve } from 'node:path'
 
-import { copyEntries, ensureDir, removeIfExists } from './cli-utils.mjs'
+import { copyEntries, createLink, ensureDir, removeIfExists } from './cli-utils.mjs'
 
 export const RUNTIME_ROOT_ENTRIES = [
   '.claude-plugin',
@@ -28,6 +28,16 @@ export function getStableRuntimeRoot(home) {
   return join(home, '.helloagents', 'helloagents')
 }
 
+/** Return the Claude local marketplace projection root derived from the shared runtime copy. */
+export function getClaudeMarketplaceRoot(home) {
+  return join(home, '.helloagents', 'host-projections', 'claude-marketplace')
+}
+
+/** Return the Gemini extension projection root derived from the shared runtime copy. */
+export function getGeminiExtensionRoot(home) {
+  return join(home, '.helloagents', 'host-projections', 'gemini')
+}
+
 function normalizePath(path) {
   const resolved = resolve(path)
   try {
@@ -63,17 +73,9 @@ function retryTransientFs(operation) {
   throw lastError
 }
 
-function materializeGeminiHooks(root) {
-  const source = join(root, 'hooks', 'hooks-gemini.json')
-  const target = join(root, 'hooks', 'hooks.json')
-  if (!existsSync(source)) return
-  copyFileSync(source, target)
-}
-
-/** Sync package runtime files into the stable root without copying repo-only files. */
-export function syncRuntimeRoot(sourceRoot, runtimeRoot) {
+function syncRuntimeTree(sourceRoot, targetRoot, { materializeGeminiHooks = false } = {}) {
   const source = resolve(sourceRoot)
-  const target = resolve(runtimeRoot)
+  const target = resolve(targetRoot)
   if (samePath(source, target)) {
     return { synced: false, root: target }
   }
@@ -84,7 +86,13 @@ export function syncRuntimeRoot(sourceRoot, runtimeRoot) {
 
   try {
     copyEntries(source, staging, RUNTIME_ROOT_ENTRIES)
-    materializeGeminiHooks(staging)
+    if (materializeGeminiHooks) {
+      const sourceHooks = join(staging, 'hooks', 'hooks-gemini.json')
+      const targetHooks = join(staging, 'hooks', 'hooks.json')
+      if (existsSync(sourceHooks)) {
+        copyFileSync(sourceHooks, targetHooks)
+      }
+    }
     retryTransientFs(() => {
       removeIfExists(target)
       renameSync(staging, target)
@@ -96,7 +104,42 @@ export function syncRuntimeRoot(sourceRoot, runtimeRoot) {
   }
 }
 
+/** Sync package runtime files into the stable root without copying repo-only files. */
+export function syncRuntimeRoot(sourceRoot, runtimeRoot) {
+  return syncRuntimeTree(sourceRoot, runtimeRoot)
+}
+
+/** Sync a Claude local marketplace root that resolves to the stable runtime copy. */
+export function syncClaudeMarketplaceRoot(sourceRoot, marketplaceRoot) {
+  const source = resolve(sourceRoot)
+  const target = resolve(marketplaceRoot)
+  if (samePath(source, target)) {
+    return { synced: false, root: target }
+  }
+
+  removeIfExists(target)
+  if (createLink(source, target)) {
+    return { synced: true, root: target }
+  }
+  return syncRuntimeTree(source, target)
+}
+
+/** Sync a host-specific extension root derived from the stable runtime copy. */
+export function syncGeminiExtensionRoot(sourceRoot, extensionRoot) {
+  return syncRuntimeTree(sourceRoot, extensionRoot, { materializeGeminiHooks: true })
+}
+
 /** Remove the stable runtime copy while leaving user settings under ~/.helloagents intact. */
 export function removeRuntimeRoot(runtimeRoot) {
   removeIfExists(runtimeRoot)
 }
+
+/** Remove the Claude marketplace projection root. */
+export function removeClaudeMarketplaceRoot(home) {
+  removeIfExists(getClaudeMarketplaceRoot(home))
+}
+
+/** Remove the Gemini extension projection root. */
+export function removeGeminiExtensionRoot(home) {
+  removeIfExists(getGeminiExtensionRoot(home))
+}

package/scripts/cli-toml.mjs

@@ -117,6 +117,10 @@ export function removeTopLevelTomlBlock(text, key) {
   return normalizeToml(`${normalized.slice(0, existing.start)}${normalized.slice(existing.end)}`);
 }
 
+export function hasTopLevelTomlBlock(text, key) {
+  return Boolean(findTopLevelTomlBlock(text, key));
+}
+
 export function prependTopLevelTomlBlocks(text, blocks) {
   const normalizedBlocks = blocks
     .map((block) => String(block || '').trim())

package/scripts/project-session-cleanup.mjs

@@ -23,10 +23,6 @@ function removePath(filePath, result, bucket) {
   }
 }
 
-function isDebugLog(entryName = '') {
-  return /\.log$/i.test(entryName)
-}
-
 function isDirectoryEmptyRecursive(dirPath) {
   const entries = readdirSync(dirPath, { withFileTypes: true })
   if (entries.length === 0) return true
@@ -92,32 +88,6 @@ function cleanupTransientSessionTemps(sessionsDir, result) {
   }
 }
 
-function cleanupLegacyProjectArtifacts(activationDir, result) {
-  const artifactsDir = join(activationDir, 'artifacts')
-  if (!existsSync(artifactsDir)) return
-
-  let removableEntries = []
-  try {
-    removableEntries = readdirSync(artifactsDir, { withFileTypes: true })
-  } catch (error) {
-    result.errors.push(`${artifactsDir}: ${error.message}`)
-    return
-  }
-
-  for (const entry of removableEntries) {
-    if (!entry.isFile() || !isDebugLog(entry.name)) continue
-    removePath(join(artifactsDir, entry.name), result, 'removedLegacyArtifacts')
-  }
-
-  try {
-    if (isDirectoryEmptyRecursive(artifactsDir)) {
-      removePath(artifactsDir, result, 'removedLegacyArtifacts')
-    }
-  } catch (error) {
-    result.errors.push(`${artifactsDir}: ${error.message}`)
-  }
-}
-
 export function cleanupProjectSessions(cwd, { now = Date.now(), minIntervalMs = 0, maxAgeMs = PROJECT_SESSION_MAX_AGE_MS } = {}) {
   const projectRoot = getProjectRoot(cwd)
   const activationDir = getProjectActivationDir(projectRoot)
@@ -131,7 +101,6 @@ export function cleanupProjectSessions(cwd, { now = Date.now(), minIntervalMs =
     removedNoStateDirs: [],
     removedSeedDirs: [],
     removedTempFiles: [],
-    removedLegacyArtifacts: [],
     errors: [],
     skipped: false,
   }
@@ -150,7 +119,6 @@ export function cleanupProjectSessions(cwd, { now = Date.now(), minIntervalMs =
   } catch (error) {
     result.errors.push(`${sessionsDir}: ${error.message}`)
   }
-  cleanupLegacyProjectArtifacts(activationDir, result)
 
   for (const workspaceEntry of readdirSync(sessionsDir, { withFileTypes: true })) {
     if (!workspaceEntry.isDirectory()) continue

package/scripts/runtime-scope.mjs

@@ -5,14 +5,17 @@ import { dirname, join, normalize, resolve } from 'node:path'
 import { homedir } from 'node:os'
 
 import {
+  PROJECT_CONVERSATION_PAYLOAD_KEYS,
+  PROJECT_SESSION_PAYLOAD_KEYS,
+  PROJECT_THREAD_PAYLOAD_KEYS,
   resolveProjectSessionAliasToken,
   resolveProjectSessionToken,
   resolveSessionToken,
+  sanitizeSessionToken,
 } from './session-token.mjs'
 import { USER_RUNTIME_MAX_AGE_MS } from './runtime-ttl.mjs'
 import { cleanupUserRuntimeRoot, getUserRuntimeRoot } from './runtime-user-cleanup.mjs'
 import { FULL_CARRIER_PROFILE_MARKER } from './cli-utils.mjs'
-import { readStateDocument, writeStateDocument } from './state-document.mjs'
 
 export const PROJECT_DIR_NAME = '.helloagents'
 export const PROJECT_SESSIONS_DIR_NAME = 'sessions'
@@ -21,7 +24,6 @@ export const EVENTS_FILE_NAME = 'events.jsonl'
 export const ACTIVE_SESSION_FILE_NAME = 'active.json'
 export const PROJECT_RUNTIME_FILE_NAME = 'runtime.json'
 export const DEFAULT_STATE_SESSION_TOKEN = 'default'
-export const LEGACY_SESSION_POINTERS_FILE_NAME = 'session-pointers.json'
 export const USER_RUNTIME_DIR_NAME = 'runtime'
 export { cleanupUserRuntimeRoot, getUserRuntimeRoot, USER_RUNTIME_MAX_AGE_MS }
 
@@ -267,38 +269,6 @@ function buildInitialStateSnapshot({
   ].join('\n')
 }
 
-function normalizeProjectSessionState(scope) {
-  if (!scope?.statePath) return
-
-  const currentDocument = readStateDocument(scope.statePath)
-  if (currentDocument.hasMetadata) {
-    if (currentDocument.metadata && typeof currentDocument.metadata === 'object' && !existsSync(scope.runtimePath)) {
-      writeJsonFileAtomic(scope.runtimePath, currentDocument.metadata)
-    }
-    writeStateDocument(scope.statePath, {
-      body: currentDocument.body,
-    })
-  }
-
-  const workspaceStatePath = scope.workspaceDir ? join(scope.workspaceDir, 'STATE.md') : ''
-  if (!workspaceStatePath || samePath(workspaceStatePath, scope.statePath) || !existsSync(workspaceStatePath)) return
-
-  const legacyDocument = readStateDocument(workspaceStatePath)
-  if (!existsSync(scope.statePath) && legacyDocument.body.trim()) {
-    writeStateDocument(scope.statePath, {
-      body: legacyDocument.body,
-    })
-  }
-  if (legacyDocument.metadata && typeof legacyDocument.metadata === 'object' && !existsSync(scope.runtimePath)) {
-    writeJsonFileAtomic(scope.runtimePath, legacyDocument.metadata)
-  }
-  if (legacyDocument.hasMetadata) {
-    writeStateDocument(workspaceStatePath, {
-      body: legacyDocument.body,
-    })
-  }
-}
-
 export function ensureProjectLocalRuntime(cwd, options = {}) {
   const normalizedCwd = normalizePath(cwd || process.cwd())
   const localDir = getProjectLocalDir(normalizedCwd)
@@ -310,7 +280,6 @@ export function ensureProjectLocalRuntime(cwd, options = {}) {
   if (!existsSync(scope.statePath)) {
     writeFileSync(scope.statePath, `${buildInitialStateSnapshot(options.stateSeed || {})}\n`, 'utf-8')
   }
-  normalizeProjectSessionState(scope)
 
   return scope
 }
@@ -369,6 +338,31 @@ function resolvePayloadSessionToken(payload = {}) {
   })
 }
 
+function readRawPayloadValue(payload = {}, key = '') {
+  if (!payload || typeof payload !== 'object') return ''
+  const value = payload[key]
+  if (typeof value === 'string') return value.trim()
+  if (typeof value === 'number') return String(value)
+  return ''
+}
+
+function readPayloadSessionIdentity(payload = {}) {
+  const groups = [
+    ['session', PROJECT_SESSION_PAYLOAD_KEYS],
+    ['conversation', PROJECT_CONVERSATION_PAYLOAD_KEYS],
+    ['thread', PROJECT_THREAD_PAYLOAD_KEYS],
+  ]
+
+  for (const [kind, keys] of groups) {
+    for (const key of keys) {
+      const value = sanitizeRuntimeSegment(sanitizeSessionToken(readRawPayloadValue(payload, key)), '')
+      if (value) return { kind, token: value }
+    }
+  }
+
+  return { kind: '', token: '' }
+}
+
 function resolveEnvSessionToken(env = process.env) {
   return resolveProjectSessionToken({ payload: {}, env })
 }
@@ -377,6 +371,17 @@ function resolveEnvSessionAliasToken(env = process.env) {
   return resolveProjectSessionAliasToken({ env })
 }
 
+function resolveProjectSessionHostHint({ env = process.env, ppid = process.ppid } = {}) {
+  const envToken = sanitizeRuntimeSegment(resolveEnvSessionToken(env), '')
+  if (envToken) return `host:${envToken}`
+
+  const envAliasToken = sanitizeRuntimeSegment(resolveEnvSessionAliasToken(env), '')
+  if (envAliasToken) return `alias:${envAliasToken}`
+
+  const parentToken = sanitizeRuntimeSegment(String(ppid || '').trim(), '')
+  return parentToken ? `ppid:${parentToken}` : ''
+}
+
 function resolveTransientSessionToken({ payload = {}, env = process.env, ppid = process.ppid } = {}) {
   return resolveSessionToken({
     payload,
@@ -393,18 +398,33 @@ function buildScopedSessionToken(kind = '', raw = '') {
   return `${normalizedKind}-${value}`
 }
 
-function getActiveSessionPath(activationDir) {
-  return join(activationDir, PROJECT_SESSIONS_DIR_NAME, ACTIVE_SESSION_FILE_NAME)
+function buildSessionAliasKeys({ payload = {}, env = process.env } = {}) {
+  const keys = []
+  const payloadIdentity = readPayloadSessionIdentity(payload)
+  if (payloadIdentity.token) {
+    keys.push(`${payloadIdentity.kind}:${payloadIdentity.token}`)
+  }
+
+  const envSession = sanitizeRuntimeSegment(resolveEnvSessionToken(env), '')
+  if (envSession && !payloadIdentity.token) keys.push(`host:${envSession}`)
+
+  const payloadAlias = sanitizeRuntimeSegment(sanitizeSessionToken(payload?._helloagentsSessionAlias), '')
+  if (payloadAlias) keys.push(`alias:${payloadAlias}`)
+
+  const envAlias = sanitizeRuntimeSegment(resolveEnvSessionAliasToken(env), '')
+  if (envAlias && envSession && envAlias === envSession) {
+    return [...new Set(keys.filter(Boolean))]
+  }
+  if (envAlias) keys.push(`alias:${envAlias}`)
+
+  return [...new Set(keys.filter(Boolean))]
 }
 
-function removeLegacySessionPointersFile(activationDir) {
-  if (!activationDir) return
-  try {
-    rmSync(join(activationDir, PROJECT_SESSIONS_DIR_NAME, LEGACY_SESSION_POINTERS_FILE_NAME), { force: true })
-  } catch {}
+function getActiveSessionPath(activationDir) {
+  return join(activationDir, PROJECT_SESSIONS_DIR_NAME, ACTIVE_SESSION_FILE_NAME)
 }
 
-function resolveActiveSessionToken({ activationDir, projectRoot, workspace, now = Date.now() } = {}) {
+function readActiveProjectSession({ activationDir, projectRoot, workspace, now = Date.now() } = {}) {
   const active = readJsonFile(getActiveSessionPath(activationDir), null)
   if (!active || typeof active !== 'object') return ''
   if (active.cwd && !samePath(active.cwd, projectRoot)) return ''
@@ -415,43 +435,77 @@ function resolveActiveSessionToken({ activationDir, projectRoot, workspace, now
   const updatedAt = Date.parse(active.updatedAt || '')
   if (!Number.isFinite(updatedAt) || now - updatedAt > USER_RUNTIME_MAX_AGE_MS) return ''
 
-  return sanitizeRuntimeSegment(active.session, '')
+  return active
 }
 
 function resolveActiveAliasSession({ activationDir, projectRoot, workspace, alias, now = Date.now() } = {}) {
   if (!alias) return ''
-  const active = readJsonFile(getActiveSessionPath(activationDir), null)
+  const active = readActiveProjectSession({
+    activationDir,
+    projectRoot,
+    workspace,
+    now,
+  })
   if (!active || typeof active !== 'object') return ''
-  if (active.cwd && !samePath(active.cwd, projectRoot)) return ''
 
-  const activeWorkspace = sanitizeRuntimeSegment(active.workspace || active.branch || '', '')
-  if (activeWorkspace && activeWorkspace !== workspace) return ''
+  const aliases = active.aliases && typeof active.aliases === 'object' ? active.aliases : {}
+  const mapped = sanitizeRuntimeSegment(aliases[alias], '')
+  if (mapped) return mapped
+  if (
+    Object.prototype.hasOwnProperty.call(aliases, alias)
+    && resolveActiveSessionToken(active, join(activationDir, PROJECT_SESSIONS_DIR_NAME, workspace)) === DEFAULT_STATE_SESSION_TOKEN
+  ) {
+    return DEFAULT_STATE_SESSION_TOKEN
+  }
+  return ''
+}
 
-  const updatedAt = Date.parse(active.updatedAt || '')
-  if (!Number.isFinite(updatedAt) || now - updatedAt > USER_RUNTIME_MAX_AGE_MS) return ''
+function choosePreferredProjectSession(activeSession = '', candidates = []) {
+  for (const candidate of candidates) {
+    if (!candidate) continue
+    if (activeSession && candidate === activeSession) return candidate
+  }
+  return candidates.find(Boolean) || ''
+}
 
-  const aliases = active.aliases && typeof active.aliases === 'object' ? active.aliases : {}
-  return sanitizeRuntimeSegment(aliases[alias], '')
+function resolveActiveSessionToken(active = {}, workspaceDir = '') {
+  const session = sanitizeRuntimeSegment(active?.session || '', '')
+  if (session) return session
+
+  const defaultStatePath = workspaceDir
+    ? join(workspaceDir, DEFAULT_STATE_SESSION_TOKEN, 'STATE.md')
+    : ''
+  return defaultStatePath && existsSync(defaultStatePath)
+    ? DEFAULT_STATE_SESSION_TOKEN
+    : ''
 }
 
-export function writeActiveProjectSession(scope, { host = '', source = '', env = process.env } = {}) {
+export function writeActiveProjectSession(scope, { host = '', source = '', payload = {}, env = process.env, ppid = process.ppid } = {}) {
   if (!scope?.active || !scope.activationDir || !scope.workspace) return ''
 
   const activePath = getActiveSessionPath(scope.activationDir)
   const current = readJsonFile(activePath, null) || {}
-  const aliases = current.aliases && typeof current.aliases === 'object' ? current.aliases : {}
-  const envToken = sanitizeRuntimeSegment(resolveEnvSessionToken(env), '')
-  if (envToken && envToken !== scope.session) aliases[envToken] = scope.session
-  const aliasToken = sanitizeRuntimeSegment(resolveEnvSessionAliasToken(env), '')
-  if (aliasToken && aliasToken !== scope.session) aliases[aliasToken] = scope.session
+  const aliases = current.aliases && typeof current.aliases === 'object' ? { ...current.aliases } : {}
+  const session = scope.session || DEFAULT_STATE_SESSION_TOKEN
+  const sessionMode = scope.session
+    ? scope.sessionMode
+    : 'default'
+  const hostHint = resolveProjectSessionHostHint({ env, ppid }) || current.hostHint || ''
+  const aliasKeys = buildSessionAliasKeys({ payload, env })
+  for (const aliasKey of aliasKeys) {
+    aliases[aliasKey] = session
+    const [, aliasValue = ''] = String(aliasKey).split(':')
+    if (aliasValue) aliases[aliasValue] = session
+  }
   writeJsonFileAtomic(activePath, {
     version: 1,
     cwd: scope.cwd,
     workspace: scope.workspace || scope.branch,
-    session: scope.session,
-    sessionMode: scope.sessionMode,
+    session,
+    sessionMode,
     host,
     source,
+    ...(hostHint ? { hostHint } : {}),
     aliases,
     ...(current.cleanupCheckedAt ? { cleanupCheckedAt: current.cleanupCheckedAt } : {}),
     updatedAt: new Date().toISOString(),
@@ -459,23 +513,73 @@ export function writeActiveProjectSession(scope, { host = '', source = '', env =
   return activePath
 }
 
-function chooseProjectSession({ payload, env, activationDir, projectRoot, workspace }) {
-  const payloadToken = sanitizeRuntimeSegment(resolvePayloadSessionToken(payload), '')
-  const payloadAlias = sanitizeRuntimeSegment(payload?._helloagentsSessionAlias, '')
+function chooseProjectSession({ payload, env, ppid, activationDir, projectRoot, workspace }) {
+  const workspaceDir = join(activationDir, PROJECT_SESSIONS_DIR_NAME, workspace)
+  const active = readActiveProjectSession({
+    activationDir,
+    projectRoot,
+    workspace,
+  })
+  const activeSession = resolveActiveSessionToken(active, workspaceDir)
+  const payloadIdentity = readPayloadSessionIdentity(payload)
+  const payloadToken = payloadIdentity.token
+  const payloadAlias = sanitizeRuntimeSegment(sanitizeSessionToken(payload?._helloagentsSessionAlias), '')
+  const payloadAliases = [
+    payloadIdentity.token ? `${payloadIdentity.kind}:${payloadIdentity.token}` : '',
+    payloadAlias ? `alias:${payloadAlias}` : '',
+  ].filter(Boolean)
+  const payloadMappedSession = choosePreferredProjectSession(
+    activeSession,
+    payloadAliases.map((alias) => resolveActiveAliasSession({
+      activationDir,
+      projectRoot,
+      workspace,
+      alias,
+    })),
+  )
+  if (payloadMappedSession) {
+    return { session: payloadMappedSession, sessionMode: 'active-session' }
+  }
+
+  const envToken = sanitizeRuntimeSegment(resolveEnvSessionToken(env), '')
+  const envAliasToken = sanitizeRuntimeSegment(resolveEnvSessionAliasToken(env), '')
+  const envMappedSession = choosePreferredProjectSession(
+    activeSession,
+    [
+      envToken ? resolveActiveAliasSession({
+        activationDir,
+        projectRoot,
+        workspace,
+        alias: `host:${envToken}`,
+      }) : '',
+      envAliasToken ? resolveActiveAliasSession({
+        activationDir,
+        projectRoot,
+        workspace,
+        alias: `alias:${envAliasToken}`,
+      }) : '',
+    ],
+  )
+  if (envMappedSession) return { session: envMappedSession, sessionMode: 'active-session' }
+
+  if (
+    activeSession === DEFAULT_STATE_SESSION_TOKEN
+    && active?.hostHint
+    && active.hostHint === resolveProjectSessionHostHint({ env, ppid })
+    && (payloadToken || payloadAlias || envToken || envAliasToken)
+  ) {
+    return {
+      session: activeSession,
+      sessionMode: 'active-session',
+    }
+  }
+
   if (payloadToken) {
     return {
       session: buildScopedSessionToken('host', payloadToken),
       sessionMode: 'host-session',
     }
   }
-
-  const payloadAliasToken = resolveActiveAliasSession({
-    activationDir,
-    projectRoot,
-    workspace,
-    alias: payloadAlias,
-  })
-  if (payloadAliasToken) return { session: payloadAliasToken, sessionMode: 'active-session' }
   if (payloadAlias) {
     return {
       session: buildScopedSessionToken('alias', payloadAlias),
@@ -483,16 +587,6 @@ function chooseProjectSession({ payload, env, activationDir, projectRoot, worksp
     }
   }
 
-  const envToken = sanitizeRuntimeSegment(resolveEnvSessionToken(env), '')
-  const envAliasToken = sanitizeRuntimeSegment(resolveEnvSessionAliasToken(env), '')
-  const aliasToken = resolveActiveAliasSession({
-    activationDir,
-    projectRoot,
-    workspace,
-    alias: envToken,
-  })
-  if (aliasToken) return { session: aliasToken, sessionMode: 'active-session' }
-
   if (envToken) {
     return {
       session: buildScopedSessionToken('host', envToken),
@@ -501,42 +595,33 @@ function chooseProjectSession({ payload, env, activationDir, projectRoot, worksp
   }
 
   if (envAliasToken) {
-    const activeAliasToken = resolveActiveAliasSession({
-      activationDir,
-      projectRoot,
-      workspace,
-      alias: envAliasToken,
-    })
-    if (activeAliasToken) return { session: activeAliasToken, sessionMode: 'active-session' }
     return {
       session: buildScopedSessionToken('alias', envAliasToken),
       sessionMode: 'alias-session',
     }
   }
 
-  return { session: '', sessionMode: 'unidentified' }
-}
+  const source = String(payload?.source || '').trim().toLowerCase()
+  if ((source === 'resume' || source === 'compact') && activeSession) {
+    return {
+      session: activeSession,
+      sessionMode: 'active-session',
+    }
+  }
 
-function removeLegacyProjectArtifacts(activationDir) {
-  if (!activationDir) return
-  const artifactsDir = join(activationDir, PROJECT_ARTIFACTS_DIR_NAME)
-  if (!existsSync(artifactsDir)) return
-  try {
-    rmSync(artifactsDir, { recursive: true, force: true })
-  } catch {}
+  return { session: '', sessionMode: 'unidentified' }
 }
 
 export function getProjectSessionScope(cwd, options = {}) {
   const normalizedCwd = normalizePath(cwd || process.cwd())
   const projectRoot = getProjectRoot(normalizedCwd)
-  const { payload = {}, env = process.env } = normalizeRuntimeOptions(options)
+  const { payload = {}, env = process.env, ppid = process.ppid } = normalizeRuntimeOptions(options)
   const activationDir = getProjectActivationDir(projectRoot)
-  removeLegacyProjectArtifacts(activationDir)
-  removeLegacySessionPointersFile(activationDir)
   const workspace = resolveWorkspaceName(projectRoot)
   const { session, sessionMode } = chooseProjectSession({
     payload,
     env,
+    ppid,
     activationDir,
     projectRoot,
     workspace,