@xortex/xcode 3.0.0

package/utils/planModeV2.ts

@@ -0,0 +1,95 @@
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'
+import { getRateLimitTier, getSubscriptionType } from './auth.js'
+import { isEnvDefinedFalsy, isEnvTruthy } from './envUtils.js'
+
+export function getPlanModeV2AgentCount(): number {
+  // Environment variable override takes precedence
+  if (process.env.CLAUDE_CODE_PLAN_V2_AGENT_COUNT) {
+    const count = parseInt(process.env.CLAUDE_CODE_PLAN_V2_AGENT_COUNT, 10)
+    if (!isNaN(count) && count > 0 && count <= 10) {
+      return count
+    }
+  }
+
+  const subscriptionType = getSubscriptionType()
+  const rateLimitTier = getRateLimitTier()
+
+  if (
+    subscriptionType === 'max' &&
+    rateLimitTier === 'default_claude_max_20x'
+  ) {
+    return 3
+  }
+
+  if (subscriptionType === 'enterprise' || subscriptionType === 'team') {
+    return 3
+  }
+
+  return 1
+}
+
+export function getPlanModeV2ExploreAgentCount(): number {
+  if (process.env.CLAUDE_CODE_PLAN_V2_EXPLORE_AGENT_COUNT) {
+    const count = parseInt(
+      process.env.CLAUDE_CODE_PLAN_V2_EXPLORE_AGENT_COUNT,
+      10,
+    )
+    if (!isNaN(count) && count > 0 && count <= 10) {
+      return count
+    }
+  }
+
+  return 3
+}
+
+/**
+ * Check if plan mode interview phase is enabled.
+ *
+ * Config: ant=always_on, external=tengu_plan_mode_interview_phase gate, envVar=true
+ */
+export function isPlanModeInterviewPhaseEnabled(): boolean {
+  // Always on for ants
+  if (process.env.USER_TYPE === 'ant') return true
+
+  const env = process.env.CLAUDE_CODE_PLAN_MODE_INTERVIEW_PHASE
+  if (isEnvTruthy(env)) return true
+  if (isEnvDefinedFalsy(env)) return false
+
+  return getFeatureValue_CACHED_MAY_BE_STALE(
+    'tengu_plan_mode_interview_phase',
+    false,
+  )
+}
+
+export type PewterLedgerVariant = 'trim' | 'cut' | 'cap' | null
+
+/**
+ * tengu_pewter_ledger — plan file structure prompt experiment.
+ *
+ * Controls the Phase 4 "Final Plan" bullets in the 5-phase plan mode
+ * workflow (messages.ts getPlanPhase4Section). 5-phase is 99% of plan
+ * traffic; interview-phase (ants) is untouched as a reference population.
+ *
+ * Arms: null (control), 'trim', 'cut', 'cap' — progressively stricter
+ * guidance on plan file size.
+ *
+ * Baseline (control, 14d ending 2026-03-02, N=26.3M):
+ *   p50 4,906 chars | p90 11,617 | mean 6,207 | 82% Opus 4.6
+ *   Reject rate monotonic with size: 20% at <2K → 50% at 20K+
+ *
+ * Primary: session-level Avg Cost (fact__201omjcij85f) — Opus output is
+ *   5× input price so cost is an output-weighted proxy. planLengthChars
+ *   on tengu_plan_exit is the mechanism but NOT the goal — the cap arm
+ *   could shrink the plan file while increasing total output via
+ *   write→count→edit cycles.
+ * Guardrail: feedback-bad rate, requests/session (too-thin plans →
+ *   more implementation iterations), tool error rate
+ */
+export function getPewterLedgerVariant(): PewterLedgerVariant {
+  const raw = getFeatureValue_CACHED_MAY_BE_STALE<string | null>(
+    'tengu_pewter_ledger',
+    null,
+  )
+  if (raw === 'trim' || raw === 'cut' || raw === 'cap') return raw
+  return null
+}

package/utils/plans.ts

@@ -0,0 +1,397 @@
+import { randomUUID } from 'crypto'
+import { copyFile, writeFile } from 'fs/promises'
+import memoize from 'lodash-es/memoize.js'
+import { join, resolve, sep } from 'path'
+import type { AgentId, SessionId } from 'src/types/ids.js'
+import type { LogOption } from 'src/types/logs.js'
+import type {
+  AssistantMessage,
+  AttachmentMessage,
+  SystemFileSnapshotMessage,
+  UserMessage,
+} from 'src/types/message.js'
+import { getPlanSlugCache, getSessionId } from '../bootstrap/state.js'
+import { EXIT_PLAN_MODE_V2_TOOL_NAME } from '../tools/ExitPlanModeTool/constants.js'
+import { getCwd } from './cwd.js'
+import { logForDebugging } from './debug.js'
+import { getClaudeConfigHomeDir } from './envUtils.js'
+import { isENOENT } from './errors.js'
+import { getEnvironmentKind } from './filePersistence/outputsScanner.js'
+import { getFsImplementation } from './fsOperations.js'
+import { logError } from './log.js'
+import { getInitialSettings } from './settings/settings.js'
+import { generateWordSlug } from './words.js'
+
+const MAX_SLUG_RETRIES = 10
+
+/**
+ * Get or generate a word slug for the current session's plan.
+ * The slug is generated lazily on first access and cached for the session.
+ * If a plan file with the generated slug already exists, retries up to 10 times.
+ */
+export function getPlanSlug(sessionId?: SessionId): string {
+  const id = sessionId ?? getSessionId()
+  const cache = getPlanSlugCache()
+  let slug = cache.get(id)
+  if (!slug) {
+    const plansDir = getPlansDirectory()
+    // Try to find a unique slug that doesn't conflict with existing files
+    for (let i = 0; i < MAX_SLUG_RETRIES; i++) {
+      slug = generateWordSlug()
+      const filePath = join(plansDir, `${slug}.md`)
+      if (!getFsImplementation().existsSync(filePath)) {
+        break
+      }
+    }
+    cache.set(id, slug!)
+  }
+  return slug!
+}
+
+/**
+ * Set a specific plan slug for a session (used when resuming a session)
+ */
+export function setPlanSlug(sessionId: SessionId, slug: string): void {
+  getPlanSlugCache().set(sessionId, slug)
+}
+
+/**
+ * Clear the plan slug for the current session.
+ * This should be called on /clear to ensure a fresh plan file is used.
+ */
+export function clearPlanSlug(sessionId?: SessionId): void {
+  const id = sessionId ?? getSessionId()
+  getPlanSlugCache().delete(id)
+}
+
+/**
+ * Clear ALL plan slug entries (all sessions).
+ * Use this on /clear to free sub-session slug entries.
+ */
+export function clearAllPlanSlugs(): void {
+  getPlanSlugCache().clear()
+}
+
+// Memoized: called from render bodies (FileReadTool/FileEditTool/FileWriteTool UI.tsx)
+// and permission checks. Inputs (initial settings + cwd) are fixed at startup, so the
+// mkdirSync result is stable for the session. Without memoization, each rendered tool
+// message triggers a mkdirSync syscall (regressed in #20005).
+export const getPlansDirectory = memoize(function getPlansDirectory(): string {
+  const settings = getInitialSettings()
+  const settingsDir = settings.plansDirectory
+  let plansPath: string
+
+  if (settingsDir) {
+    // Settings.json (relative to project root)
+    const cwd = getCwd()
+    const resolved = resolve(cwd, settingsDir)
+
+    // Validate path stays within project root to prevent path traversal
+    if (!resolved.startsWith(cwd + sep) && resolved !== cwd) {
+      logError(
+        new Error(`plansDirectory must be within project root: ${settingsDir}`),
+      )
+      plansPath = join(getClaudeConfigHomeDir(), 'plans')
+    } else {
+      plansPath = resolved
+    }
+  } else {
+    // Default
+    plansPath = join(getClaudeConfigHomeDir(), 'plans')
+  }
+
+  // Ensure directory exists (mkdirSync with recursive: true is a no-op if it exists)
+  try {
+    getFsImplementation().mkdirSync(plansPath)
+  } catch (error) {
+    logError(error)
+  }
+
+  return plansPath
+})
+
+/**
+ * Get the file path for a session's plan
+ * @param agentId Optional agent ID for subagents. If not provided, returns main session plan.
+ * For main conversation (no agentId), returns {planSlug}.md
+ * For subagents (agentId provided), returns {planSlug}-agent-{agentId}.md
+ */
+export function getPlanFilePath(agentId?: AgentId): string {
+  const planSlug = getPlanSlug(getSessionId())
+
+  // Main conversation: simple filename with word slug
+  if (!agentId) {
+    return join(getPlansDirectory(), `${planSlug}.md`)
+  }
+
+  // Subagents: include agent ID
+  return join(getPlansDirectory(), `${planSlug}-agent-${agentId}.md`)
+}
+
+/**
+ * Get the plan content for a session
+ * @param agentId Optional agent ID for subagents. If not provided, returns main session plan.
+ */
+export function getPlan(agentId?: AgentId): string | null {
+  const filePath = getPlanFilePath(agentId)
+  try {
+    return getFsImplementation().readFileSync(filePath, { encoding: 'utf-8' })
+  } catch (error) {
+    if (isENOENT(error)) return null
+    logError(error)
+    return null
+  }
+}
+
+/**
+ * Extract the plan slug from a log's message history.
+ */
+function getSlugFromLog(log: LogOption): string | undefined {
+  return log.messages.find(m => m.slug)?.slug
+}
+
+/**
+ * Restore plan slug from a resumed session.
+ * Sets the slug in the session cache so getPlanSlug returns it.
+ * If the plan file is missing, attempts to recover it from a file snapshot
+ * (written incrementally during the session) or from message history.
+ * Returns true if a plan file exists (or was recovered) for the slug.
+ * @param log The log to restore from
+ * @param targetSessionId The session ID to associate the plan slug with.
+ *                        This should be the ORIGINAL session ID being resumed,
+ *                        not the temporary session ID from before resume.
+ */
+export async function copyPlanForResume(
+  log: LogOption,
+  targetSessionId?: SessionId,
+): Promise<boolean> {
+  const slug = getSlugFromLog(log)
+  if (!slug) {
+    return false
+  }
+
+  // Set the slug for the target session ID (or current if not provided)
+  const sessionId = targetSessionId ?? getSessionId()
+  setPlanSlug(sessionId, slug)
+
+  // Attempt to read the plan file directly — recovery triggers on ENOENT.
+  const planPath = join(getPlansDirectory(), `${slug}.md`)
+  try {
+    await getFsImplementation().readFile(planPath, { encoding: 'utf-8' })
+    return true
+  } catch (e: unknown) {
+    if (!isENOENT(e)) {
+      // Don't throw — called fire-and-forget (void copyPlanForResume(...)) with no .catch()
+      logError(e)
+      return false
+    }
+    // Only attempt recovery in remote sessions (CCR) where files don't persist
+    if (getEnvironmentKind() === null) {
+      return false
+    }
+
+    logForDebugging(
+      `Plan file missing during resume: ${planPath}. Attempting recovery.`,
+    )
+
+    // Try file snapshot first (written incrementally during session)
+    const snapshotPlan = findFileSnapshotEntry(log.messages, 'plan')
+    let recovered: string | null = null
+    if (snapshotPlan && snapshotPlan.content.length > 0) {
+      recovered = snapshotPlan.content
+      logForDebugging(
+        `Plan recovered from file snapshot, ${recovered.length} chars`,
+        { level: 'info' },
+      )
+    } else {
+      // Fall back to searching message history
+      recovered = recoverPlanFromMessages(log)
+      if (recovered) {
+        logForDebugging(
+          `Plan recovered from message history, ${recovered.length} chars`,
+          { level: 'info' },
+        )
+      }
+    }
+
+    if (recovered) {
+      try {
+        await writeFile(planPath, recovered, { encoding: 'utf-8' })
+        return true
+      } catch (writeError) {
+        logError(writeError)
+        return false
+      }
+    }
+    logForDebugging(
+      'Plan file recovery failed: no file snapshot or plan content found in message history',
+    )
+    return false
+  }
+}
+
+/**
+ * Copy a plan file for a forked session. Unlike copyPlanForResume (which reuses
+ * the original slug), this generates a NEW slug for the forked session and
+ * writes the original plan content to the new file. This prevents the original
+ * and forked sessions from clobbering each other's plan files.
+ */
+export async function copyPlanForFork(
+  log: LogOption,
+  targetSessionId: SessionId,
+): Promise<boolean> {
+  const originalSlug = getSlugFromLog(log)
+  if (!originalSlug) {
+    return false
+  }
+
+  const plansDir = getPlansDirectory()
+  const originalPlanPath = join(plansDir, `${originalSlug}.md`)
+
+  // Generate a new slug for the forked session (do NOT reuse the original)
+  const newSlug = getPlanSlug(targetSessionId)
+  const newPlanPath = join(plansDir, `${newSlug}.md`)
+  try {
+    await copyFile(originalPlanPath, newPlanPath)
+    return true
+  } catch (error) {
+    if (isENOENT(error)) {
+      return false
+    }
+    logError(error)
+    return false
+  }
+}
+
+/**
+ * Recover plan content from the message history. Plan content can appear in
+ * three forms depending on what happened during the session:
+ *
+ * 1. ExitPlanMode tool_use input — normalizeToolInput injects the plan content
+ *    into the tool_use input, which persists in the transcript.
+ *
+ * 2. planContent field on user messages — set during the "clear context and
+ *    implement" flow when ExitPlanMode is approved.
+ *
+ * 3. plan_file_reference attachment — created by auto-compact to preserve the
+ *    plan across compaction boundaries.
+ */
+function recoverPlanFromMessages(log: LogOption): string | null {
+  for (let i = log.messages.length - 1; i >= 0; i--) {
+    const msg = log.messages[i]
+    if (!msg) {
+      continue
+    }
+
+    if (msg.type === 'assistant') {
+      const { content } = (msg as AssistantMessage).message
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (
+            block.type === 'tool_use' &&
+            block.name === EXIT_PLAN_MODE_V2_TOOL_NAME
+          ) {
+            const input = block.input as Record<string, unknown> | undefined
+            const plan = input?.plan
+            if (typeof plan === 'string' && plan.length > 0) {
+              return plan
+            }
+          }
+        }
+      }
+    }
+
+    if (msg.type === 'user') {
+      const userMsg = msg as UserMessage
+      if (
+        typeof userMsg.planContent === 'string' &&
+        userMsg.planContent.length > 0
+      ) {
+        return userMsg.planContent
+      }
+    }
+
+    if (msg.type === 'attachment') {
+      const attachmentMsg = msg as AttachmentMessage
+      if (attachmentMsg.attachment?.type === 'plan_file_reference') {
+        const plan = (attachmentMsg.attachment as { planContent?: string })
+          .planContent
+        if (typeof plan === 'string' && plan.length > 0) {
+          return plan
+        }
+      }
+    }
+  }
+  return null
+}
+
+/**
+ * Find a file entry in the most recent file-snapshot system message in the transcript.
+ * Scans backwards to find the latest snapshot.
+ */
+function findFileSnapshotEntry(
+  messages: LogOption['messages'],
+  key: string,
+): { key: string; path: string; content: string } | undefined {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i]
+    if (
+      msg?.type === 'system' &&
+      'subtype' in msg &&
+      msg.subtype === 'file_snapshot' &&
+      'snapshotFiles' in msg
+    ) {
+      const files = msg.snapshotFiles as Array<{
+        key: string
+        path: string
+        content: string
+      }>
+      return files.find(f => f.key === key)
+    }
+  }
+  return undefined
+}
+
+/**
+ * Persist a snapshot of session files (plan, todos) to the transcript.
+ * Called incrementally whenever these files change. Only active in remote
+ * sessions (CCR) where local files don't persist between sessions.
+ */
+export async function persistFileSnapshotIfRemote(): Promise<void> {
+  if (getEnvironmentKind() === null) {
+    return
+  }
+  try {
+    const snapshotFiles: SystemFileSnapshotMessage['snapshotFiles'] = []
+
+    // Snapshot plan file
+    const plan = getPlan()
+    if (plan) {
+      snapshotFiles.push({
+        key: 'plan',
+        path: getPlanFilePath(),
+        content: plan,
+      })
+    }
+
+    if (snapshotFiles.length === 0) {
+      return
+    }
+
+    const message: SystemFileSnapshotMessage = {
+      type: 'system',
+      subtype: 'file_snapshot',
+      content: 'File snapshot',
+      level: 'info',
+      isMeta: true,
+      timestamp: new Date().toISOString(),
+      uuid: randomUUID(),
+      snapshotFiles,
+    }
+
+    const { recordTranscript } = await import('./sessionStorage.js')
+    await recordTranscript([message])
+  } catch (error) {
+    logError(error)
+  }
+}

package/utils/platform.ts

@@ -0,0 +1,150 @@
+import { readdir, readFile } from 'fs/promises'
+import memoize from 'lodash-es/memoize.js'
+import { release as osRelease } from 'os'
+import { getFsImplementation } from './fsOperations.js'
+import { logError } from './log.js'
+
+export type Platform = 'macos' | 'windows' | 'wsl' | 'linux' | 'unknown'
+
+export const SUPPORTED_PLATFORMS: Platform[] = ['macos', 'wsl']
+
+export const getPlatform = memoize((): Platform => {
+  try {
+    if (process.platform === 'darwin') {
+      return 'macos'
+    }
+
+    if (process.platform === 'win32') {
+      return 'windows'
+    }
+
+    if (process.platform === 'linux') {
+      // Check if running in WSL (Windows Subsystem for Linux)
+      try {
+        const procVersion = getFsImplementation().readFileSync(
+          '/proc/version',
+          { encoding: 'utf8' },
+        )
+        if (
+          procVersion.toLowerCase().includes('microsoft') ||
+          procVersion.toLowerCase().includes('wsl')
+        ) {
+          return 'wsl'
+        }
+      } catch (error) {
+        // Error reading /proc/version, assume regular Linux
+        logError(error)
+      }
+
+      // Regular Linux
+      return 'linux'
+    }
+
+    // Unknown platform
+    return 'unknown'
+  } catch (error) {
+    logError(error)
+    return 'unknown'
+  }
+})
+
+export const getWslVersion = memoize((): string | undefined => {
+  // Only check for WSL on Linux systems
+  if (process.platform !== 'linux') {
+    return undefined
+  }
+  try {
+    const procVersion = getFsImplementation().readFileSync('/proc/version', {
+      encoding: 'utf8',
+    })
+
+    // First check for explicit WSL version markers (e.g., "WSL2", "WSL3", etc.)
+    const wslVersionMatch = procVersion.match(/WSL(\d+)/i)
+    if (wslVersionMatch && wslVersionMatch[1]) {
+      return wslVersionMatch[1]
+    }
+
+    // If no explicit WSL version but contains Microsoft, assume WSL1
+    // This handles the original WSL1 format: "4.4.0-19041-Microsoft"
+    if (procVersion.toLowerCase().includes('microsoft')) {
+      return '1'
+    }
+
+    // Not WSL or unable to determine version
+    return undefined
+  } catch (error) {
+    logError(error)
+    return undefined
+  }
+})
+
+export type LinuxDistroInfo = {
+  linuxDistroId?: string
+  linuxDistroVersion?: string
+  linuxKernel?: string
+}
+
+export const getLinuxDistroInfo = memoize(
+  async (): Promise<LinuxDistroInfo | undefined> => {
+    if (process.platform !== 'linux') {
+      return undefined
+    }
+
+    const result: LinuxDistroInfo = {
+      linuxKernel: osRelease(),
+    }
+
+    try {
+      const content = await readFile('/etc/os-release', 'utf8')
+      for (const line of content.split('\n')) {
+        const match = line.match(/^(ID|VERSION_ID)=(.*)$/)
+        if (match && match[1] && match[2]) {
+          const value = match[2].replace(/^"|"$/g, '')
+          if (match[1] === 'ID') {
+            result.linuxDistroId = value
+          } else {
+            result.linuxDistroVersion = value
+          }
+        }
+      }
+    } catch {
+      // /etc/os-release may not exist on all Linux systems
+    }
+
+    return result
+  },
+)
+
+const VCS_MARKERS: Array<[string, string]> = [
+  ['.git', 'git'],
+  ['.hg', 'mercurial'],
+  ['.svn', 'svn'],
+  ['.p4config', 'perforce'],
+  ['$tf', 'tfs'],
+  ['.tfvc', 'tfs'],
+  ['.jj', 'jujutsu'],
+  ['.sl', 'sapling'],
+]
+
+export async function detectVcs(dir?: string): Promise<string[]> {
+  const detected = new Set<string>()
+
+  // Check for Perforce via env var
+  if (process.env.P4PORT) {
+    detected.add('perforce')
+  }
+
+  try {
+    const targetDir = dir ?? getFsImplementation().cwd()
+    const entries = new Set(await readdir(targetDir))
+    for (const [marker, vcs] of VCS_MARKERS) {
+      if (entries.has(marker)) {
+        detected.add(vcs)
+      }
+    }
+  } catch {
+    // Directory may not be readable
+  }
+
+  return [...detected]
+}

package/utils/plugins/addDirPluginSettings.ts

@@ -0,0 +1,71 @@
+/**
+ * Reads plugin-related settings (enabledPlugins, extraKnownMarketplaces)
+ * from --add-dir directories.
+ *
+ * These have the LOWEST priority — callers must spread standard settings
+ * on top so that user/project/local/flag/policy sources all override.
+ */
+
+import { join } from 'path'
+import type { z } from 'zod/v4'
+import { getAdditionalDirectoriesForClaudeMd } from '../../bootstrap/state.js'
+import { parseSettingsFile } from '../settings/settings.js'
+import type {
+  ExtraKnownMarketplaceSchema,
+  SettingsJson,
+} from '../settings/types.js'
+
+type ExtraKnownMarketplace = z.infer<
+  ReturnType<typeof ExtraKnownMarketplaceSchema>
+>
+
+const SETTINGS_FILES = ['settings.json', 'settings.local.json'] as const
+
+/**
+ * Returns a merged record of enabledPlugins from all --add-dir directories.
+ *
+ * Within each directory, settings.local.json is processed after settings.json
+ * (local wins within that dir). Across directories, later CLI-order wins on
+ * conflict.
+ *
+ * This has the lowest priority — callers must spread their standard settings
+ * on top to let user/project/local/flag/policy override.
+ */
+export function getAddDirEnabledPlugins(): NonNullable<
+  SettingsJson['enabledPlugins']
+> {
+  const result: NonNullable<SettingsJson['enabledPlugins']> = {}
+  for (const dir of getAdditionalDirectoriesForClaudeMd()) {
+    for (const file of SETTINGS_FILES) {
+      const { settings } = parseSettingsFile(join(dir, '.claude', file))
+      if (!settings?.enabledPlugins) {
+        continue
+      }
+      Object.assign(result, settings.enabledPlugins)
+    }
+  }
+  return result
+}
+
+/**
+ * Returns a merged record of extraKnownMarketplaces from all --add-dir directories.
+ *
+ * Same priority rules as getAddDirEnabledPlugins: settings.local.json wins
+ * within each dir, and callers spread standard settings on top.
+ */
+export function getAddDirExtraMarketplaces(): Record<
+  string,
+  ExtraKnownMarketplace
+> {
+  const result: Record<string, ExtraKnownMarketplace> = {}
+  for (const dir of getAdditionalDirectoriesForClaudeMd()) {
+    for (const file of SETTINGS_FILES) {
+      const { settings } = parseSettingsFile(join(dir, '.claude', file))
+      if (!settings?.extraKnownMarketplaces) {
+        continue
+      }
+      Object.assign(result, settings.extraKnownMarketplaces)
+    }
+  }
+  return result
+}