peachsim 0.1.630 → 0.1.631

package/cli/commands/inspect.ts

@@ -20,6 +20,8 @@ import { shouldPrintInspectNotice } from '../inspect-notice-state'
 import { levenshtein } from '../levenshtein'
 import { TOP_LEVEL_RUNTIME_COMMANDS } from '../parse-args'
 import { rethrowIfExit, rnxExit } from '../run-rnx'
+import { collectRuntimeDiagnostics } from '../runtime-diagnostics'
+import { trackCliError } from '../telemetry'
 import {
   type BridgeTransportOption,
   callInBridge,
@@ -4639,6 +4641,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
     }
   } catch (err: any) {
     rethrowIfExit(err)
+    trackCliError(err)
     const message = err instanceof Error ? err.message : String(err)
     console.error(`  ${subcommand ?? 'peach'} failed: ${message}`)
     const unknownSim = /^no sim connected with id ([^;]+)(?:; connected sims: .+)?$/.exec(
@@ -4704,6 +4707,7 @@ export async function runInspect(args: string[], opts: InspectOptions) {
     }
     rnxExit(1)
   } finally {
+    if (subcommand !== 'list') await collectRuntimeDiagnostics(bridge)
     bridge.close()
   }
 }

package/cli/commands/maestro.ts

@@ -244,7 +244,9 @@ const MAESTRO_COMPAT_VALUE_FLAGS = new Set([
   '--screen-size',
 ])
 
-function splitTagList(value: string): string[] {
+// shared with the cloud submitter, which resolves tag selection before any
+// hosted job exists the same way a local workspace run does.
+export function splitTagList(value: string): string[] {
   return value
     .split(',')
     .map((tag) => tag.trim())

package/cli/commands/project-report.ts

@@ -0,0 +1,386 @@
+// local, read-only project metadata. never evaluate config or invoke a build.
+
+import { execFileSync } from 'node:child_process'
+import { homedir, release, tmpdir } from 'node:os'
+import { basename, dirname, join, relative, resolve } from 'node:path'
+import { scanDeps } from '@peach/compat/web'
+import { getCliVersion } from '../../src/cli-version'
+import { readActiveRuntime } from '../../src/home-paths'
+import {
+  detectFramework,
+  detectMonorepoType,
+  detectPackageManager,
+  findProjectRoot,
+  metadataValue,
+  readProjectJson,
+  readProjectManifest,
+  readProjectMetadata,
+  resolveManifestVersions,
+  scanRepository,
+} from './detect'
+import type {
+  DependencyVersion,
+  ProjectReport,
+  ProjectReportEntry,
+} from './projectReportContract'
+
+function toolVersion(command: string, args = ['--version']): string | null {
+  try {
+    const text = execFileSync(command, args, {
+      encoding: 'utf8',
+      timeout: 3_000,
+      maxBuffer: 4_096,
+      cwd: tmpdir(),
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim()
+    const match =
+      command === 'xcodebuild'
+        ? /Xcode ([\d.]+)\s+Build version ([\w.]+)/.exec(text)
+        : /^v?([\d][\w.+-]*)$/.exec(text)
+    return match ? match.slice(1).join(' (build ') + (match.length > 2 ? ')' : '') : null
+  } catch {
+    return null
+  }
+}
+
+export function sanitizeProjectReportName(value: string): string {
+  return value
+    .replace(/(?:https?|file):\/\/[^\s]+/g, '<redacted>')
+    .split(homedir())
+    .join('<home>')
+    .replace(/(?:[A-Za-z]:[\\/]|\/(?:Users|home)\/)[^\s]+/g, '<home>')
+    .replace(/[^\w@./ +()<>-]/g, '_')
+    .slice(0, 240)
+}
+
+export function sanitizeProjectReportVersion(value: string): string {
+  // URL, git and local dependency specs can carry credentials or home paths.
+  return value.length <= 80 &&
+    /^(?:[v^~<>=*| ]*\d[\w.+*| <>=~-]*|[a-f\d]{7,64}|\*)$/.test(value)
+    ? value
+    : 'non-version spec (redacted)'
+}
+
+function values(text: string, pattern: RegExp): string {
+  return [...new Set([...text.matchAll(pattern)].map((match) => match[1]))].join(', ')
+}
+
+function swiftDependencies(dir: string): Record<string, DependencyVersion> {
+  const dependencies: Record<string, DependencyVersion> = {}
+  // SwiftPM v1 and v2/v3 put the pin array in different containers.
+  const parsed =
+    readProjectJson(join(dir, 'Package.resolved')) ??
+    readProjectJson(join(dir, '.swiftpm/configuration/Package.resolved'))
+  const pins =
+    metadataValue(parsed, 'pins') ??
+    metadataValue(metadataValue(parsed, 'object'), 'pins')
+  if (Array.isArray(pins))
+    for (const pin of pins) {
+      const name = metadataValue(pin, 'identity') ?? metadataValue(pin, 'package')
+      const state = metadataValue(pin, 'state')
+      const version = metadataValue(state, 'version') ?? metadataValue(state, 'revision')
+      if (typeof name === 'string' && typeof version === 'string') {
+        dependencies[sanitizeProjectReportName(name).toLowerCase()] = {
+          version: sanitizeProjectReportVersion(version),
+          source: 'lockfile',
+        }
+      }
+    }
+  return dependencies
+}
+
+function podDependencies(dir: string): Record<string, DependencyVersion> {
+  const text = readProjectMetadata(join(dir, 'Podfile.lock')) ?? ''
+  const pods = text.split(/^DEPENDENCIES:/m)[0]
+  return Object.fromEntries(
+    [...pods.matchAll(/^  - ([\w./+-]+) \(([\d][\w.+-]*)\)/gm)].map((match) => [
+      match[1],
+      {
+        version: sanitizeProjectReportVersion(match[2]),
+        source: 'lockfile',
+      } satisfies DependencyVersion,
+    ]),
+  )
+}
+
+export function createProjectReport(
+  cwd = process.cwd(),
+  exactDirectory = false,
+): ProjectReport {
+  const root = exactDirectory ? resolve(cwd) : findProjectRoot(resolve(cwd), true)
+  const scan = scanRepository(root)
+  const projects: ProjectReportEntry[] = []
+  const lockCache = new Map<string, Map<string, string>>()
+  const notes = [
+    'Only project paths, dependency versions and toolchain settings are included. No source, environment values, URLs or credentials.',
+    'Config is inspected without execution. Unspecified or dynamic engine/architecture settings are reported as unknown.',
+    'Directories named node_modules, Pods, Carthage, vendor, build, dist, dist-lib, DerivedData, coverage, target, tmp, cache, artifacts, test-results, playwright-report, and hidden directories are excluded. Directory symlinks are not followed.',
+    'Limits: 12 directory levels, 10,000 directories, 200,000 entries, 4 MiB per metadata file. Paths are relative to the scanned root.',
+  ]
+  for (const dir of scan.directories) {
+    const path = sanitizeProjectReportName(relative(root, dir) || '.')
+    const manifest = readProjectManifest(dir)
+    if (manifest) {
+      const declared = { ...manifest.dependencies, ...manifest.devDependencies }
+      const framework = detectFramework(declared)
+      if (framework !== 'unknown') {
+        const resolved = resolveManifestVersions(dir, manifest, lockCache)
+        const resolvedManifest = {
+          dependencies: Object.fromEntries(
+            Object.entries(resolved).map(([name, item]) => [name, item.version]),
+          ),
+        }
+        const nativeNames = scanDeps(resolvedManifest).packages.map((item) => item.name)
+        const dependencies: Record<string, DependencyVersion> = {}
+        for (const name of new Set([
+          'react',
+          'react-native',
+          'expo',
+          'one',
+          ...nativeNames,
+        ])) {
+          const item = resolved[name]
+          if (item)
+            dependencies[sanitizeProjectReportName(name)] = {
+              ...item,
+              version: sanitizeProjectReportVersion(item.version),
+            }
+        }
+        const expo = metadataValue(readProjectJson(join(dir, 'app.json')), 'expo')
+        const podProperties = readProjectJson(join(dir, 'ios/Podfile.properties.json'))
+        const gradle = readProjectMetadata(join(dir, 'android/gradle.properties')) ?? ''
+        const engine =
+          metadataValue(expo, 'jsEngine') ?? metadataValue(podProperties, 'expo.jsEngine')
+        const architecture =
+          metadataValue(expo, 'newArchEnabled') ??
+          metadataValue(podProperties, 'newArchEnabled')
+        const settings: Record<string, string> = {
+          jsEngine:
+            engine === 'hermes' || engine === 'jsc'
+              ? `${engine} (configured)`
+              : 'unknown (not configured in static metadata)',
+          newArchitecture:
+            typeof architecture === 'boolean' ||
+            architecture === 'true' ||
+            architecture === 'false'
+              ? `${architecture} (configured)`
+              : 'unknown (not configured in static metadata)',
+        }
+        const hermes = /^hermesEnabled\s*=\s*(true|false)\s*$/m.exec(gradle)
+        const newArch = /^newArchEnabled\s*=\s*(true|false)\s*$/m.exec(gradle)
+        if (hermes)
+          settings.androidJsEngine = `${hermes[1] === 'true' ? 'hermes' : 'jsc'} (gradle.properties)`
+        if (newArch) settings.androidNewArchitecture = `${newArch[1]} (gradle.properties)`
+        if (resolved.expo)
+          settings.expoSdk = `${sanitizeProjectReportVersion(resolved.expo.version)} (${resolved.expo.source}; expo package version)`
+        projects.push({
+          path,
+          name: sanitizeProjectReportName(manifest.name ?? basename(dir)),
+          kind: framework === 'bare' ? 'react-native' : framework,
+          settings,
+          dependencies,
+        })
+      }
+    }
+
+    const folder = basename(dir)
+    if (folder.endsWith('.xcodeproj') || folder.endsWith('.xcworkspace')) {
+      // xcodeproj's internal workspace is not a second app.
+      if (basename(dirname(dir)).endsWith('.xcodeproj')) continue
+      const pbx = readProjectMetadata(join(dir, 'project.pbxproj')) ?? ''
+      const settings: Record<string, string> = {}
+      const deployment = values(pbx, /IPHONEOS_DEPLOYMENT_TARGET\s*=\s*"?([\d.]+)/g)
+      const swift = values(pbx, /SWIFT_VERSION\s*=\s*"?([\d.]+)/g)
+      settings.iOSDeploymentTarget =
+        deployment || 'unknown (workspace or external build settings)'
+      settings.swiftVersion = swift || 'unknown (workspace or external build settings)'
+      const pins = swiftDependencies(
+        join(dir, 'project.xcworkspace/xcshareddata/swiftpm'),
+      )
+      const workspacePins = swiftDependencies(join(dir, 'xcshareddata/swiftpm'))
+      projects.push({
+        path,
+        name: sanitizeProjectReportName(folder),
+        kind: 'native-ios',
+        settings,
+        dependencies: { ...podDependencies(dirname(dir)), ...pins, ...workspacePins },
+      })
+    }
+
+    const swiftPackage = readProjectMetadata(join(dir, 'Package.swift'))
+    if (swiftPackage) {
+      const settings: Record<string, string> = {
+        swiftToolsVersion:
+          /swift-tools-version:\s*([\d.]+)/.exec(swiftPackage)?.[1] ?? 'unknown',
+        iOSDeploymentTarget:
+          values(swiftPackage, /\.iOS\(\s*\.v([\d_]+)/g).replace(/_/g, '.') ||
+          'unspecified',
+      }
+      const language = values(swiftPackage, /\.swiftLanguageMode\(\.v(\d+)/g)
+      if (language) settings.swiftLanguageVersion = language
+      const dependencies = swiftDependencies(dir)
+      for (const match of swiftPackage.matchAll(
+        /\.package\(\s*url:\s*"[^"]*\/([\w.-]+?)(?:\.git)?"\s*,\s*(?:from:|exact:)\s*"([\d.]+)"/g,
+      )) {
+        const name = sanitizeProjectReportName(match[1]).toLowerCase()
+        if (!dependencies[name])
+          dependencies[name] = { version: match[2], source: 'declared' }
+      }
+      const local = [...swiftPackage.matchAll(/\.package\(\s*path:/g)].length
+      if (local) settings.localDependencies = String(local)
+      projects.push({
+        path,
+        name: sanitizeProjectReportName(
+          /\bname:\s*"([\w .-]+)"/.exec(swiftPackage)?.[1] ?? basename(dir),
+        ),
+        kind: 'swift-package',
+        settings,
+        dependencies,
+      })
+    }
+
+    const gradleSettings =
+      readProjectMetadata(join(dir, 'settings.gradle')) ??
+      readProjectMetadata(join(dir, 'settings.gradle.kts'))
+    if (gradleSettings !== null) {
+      const buildFiles = [
+        'settings.gradle',
+        'settings.gradle.kts',
+        'build.gradle',
+        'build.gradle.kts',
+        'app/build.gradle',
+        'app/build.gradle.kts',
+        'gradle.properties',
+        'gradle/libs.versions.toml',
+      ]
+        .map((file) => readProjectMetadata(join(dir, file)) ?? '')
+        .join('\n')
+      const wrapper =
+        readProjectMetadata(join(dir, 'gradle/wrapper/gradle-wrapper.properties')) ?? ''
+      const agp =
+        values(buildFiles, /com\.android\.tools\.build:gradle:([\d.]+)/g) ||
+        values(
+          buildFiles,
+          /id\s*(?:\(\s*)?["']com\.android\.(?:application|library)["']\s*\)?\s*version\s*["']([\d.]+)/g,
+        ) ||
+        values(buildFiles, /\bagp\s*=\s*["']([\d.]+)/g)
+      const kotlin =
+        values(
+          buildFiles,
+          /(?:kotlinVersion|kotlin_version|kotlin)\s*=\s*["']([\d.]+)/g,
+        ) ||
+        values(
+          buildFiles,
+          /id\s*(?:\(\s*)?["'](?:org\.jetbrains\.kotlin\.[\w.]+|kotlin-android)["']\s*\)?\s*version\s*["']([\d.]+)/g,
+        )
+      projects.push({
+        path,
+        name: sanitizeProjectReportName(basename(dir)),
+        kind: 'android',
+        settings: {
+          gradleVersion:
+            /gradle-([\d.]+)-(?:bin|all)\.zip/.exec(wrapper)?.[1] ?? 'unknown',
+          androidGradlePluginVersion: agp || 'unknown (not a static version)',
+          kotlinVersion: kotlin || 'unknown (not a static version)',
+        },
+        dependencies: {},
+      })
+    }
+  }
+  if (scan.truncated) notes.push('Discovery reached a limit; this report is incomplete.')
+  if (scan.unreadable)
+    notes.push('Some directories could not be read; this report may be incomplete.')
+  const manager = detectPackageManager(root)
+  const rootManifest = readProjectJson(join(root, 'package.json'))
+  const packageManager = metadataValue(rootManifest, 'packageManager')
+  const managerVersion =
+    typeof packageManager === 'string'
+      ? (/^(?:bun|pnpm|npm|yarn)@([\d.]+)/.exec(packageManager)?.[1] ?? null)
+      : null
+  const runtimeVersion = readActiveRuntime()
+  return {
+    schemaVersion: 1,
+    machine: {
+      os: `${process.platform} ${release()}`,
+      arch: process.arch,
+      xcode:
+        process.platform === 'darwin' ? toolVersion('xcodebuild', ['-version']) : null,
+      node: toolVersion('node'),
+      bun: toolVersion('bun'),
+      peachCli: sanitizeProjectReportVersion(getCliVersion()),
+      peachRuntime: runtimeVersion ? sanitizeProjectReportVersion(runtimeVersion) : null,
+    },
+    repository: {
+      root: '.',
+      monorepo: detectMonorepoType(root),
+      packageManager: rootManifest ? manager : 'none detected',
+      packageManagerVersion: managerVersion,
+      directoriesScanned: scan.directories.length,
+      truncated: scan.truncated,
+      unreadableDirectories: scan.unreadable,
+    },
+    projects,
+    notes,
+  }
+}
+
+export function formatProjectReport(report: ProjectReport): string {
+  const machine = report.machine
+  const lines = [
+    'peach project report',
+    '',
+    `machine: ${machine.os} / ${machine.arch}`,
+    `tools: Xcode ${machine.xcode ?? 'not available'}, Node ${machine.node ?? 'not available'}, Bun ${machine.bun ?? 'not available'}`,
+    `peach: CLI ${machine.peachCli}, active runtime ${machine.peachRuntime ?? 'not installed'}`,
+    `repository: ${report.repository.monorepo}, ${report.repository.packageManager}${report.repository.packageManagerVersion ? ` ${report.repository.packageManagerVersion} (declared)` : ''}`,
+    `discovery: ${report.projects.length} app/package entries, ${report.repository.directoriesScanned} directories${report.repository.truncated ? ' (LIMIT REACHED)' : ''}`,
+    '',
+  ]
+  for (const entry of report.projects) {
+    lines.push(`${entry.path} [${entry.kind}] ${entry.name}`)
+    for (const [key, value] of Object.entries(entry.settings))
+      lines.push(`  ${key}: ${value}`)
+    for (const [name, item] of Object.entries(entry.dependencies))
+      lines.push(`  ${name}: ${item.version} (${item.source})`)
+    lines.push('')
+  }
+  if (!report.projects.length)
+    lines.push(
+      'No recognized React Native, Expo, native iOS, Android or Swift projects found.',
+      '',
+    )
+  lines.push(
+    ...report.notes,
+    '',
+    'To send this report: peach report-issue "<description>"',
+    'Review the preview and explicitly confirm before sending.',
+    '',
+  )
+  return lines.join('\n')
+}
+
+export function runProjectReport(args: string[]): number {
+  let app: string | undefined
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index]
+    if (arg === '--json') continue
+    if (arg === '--app' && args[index + 1] && !args[index + 1].startsWith('-')) {
+      app = args[++index]
+      continue
+    }
+    process.stderr.write(
+      `unknown flag or argument: ${arg}\nusage: peach project-report [--app <dir>] [--json]\n`,
+    )
+    return 1
+  }
+  const report = createProjectReport(
+    app ? resolve(app) : process.cwd(),
+    app !== undefined,
+  )
+  process.stdout.write(
+    args.includes('--json')
+      ? `${JSON.stringify(report, null, 2)}\n`
+      : formatProjectReport(report),
+  )
+  return 0
+}

package/cli/commands/projectReportContract.ts

@@ -0,0 +1,42 @@
+export type ProjectManifest = {
+  name?: string
+  dependencies?: Record<string, string>
+  devDependencies?: Record<string, string>
+}
+
+export type DependencyVersion = {
+  version: string
+  source: 'installed' | 'lockfile' | 'declared'
+}
+
+export type ProjectReportEntry = {
+  path: string
+  name: string
+  kind: string
+  settings: Record<string, string>
+  dependencies: Record<string, DependencyVersion>
+}
+
+export type ProjectReport = {
+  schemaVersion: 1
+  machine: {
+    os: string
+    arch: string
+    xcode: string | null
+    node: string | null
+    bun: string | null
+    peachCli: string
+    peachRuntime: string | null
+  }
+  repository: {
+    root: '.'
+    monorepo: string
+    packageManager: string
+    packageManagerVersion: string | null
+    directoriesScanned: number
+    truncated: boolean
+    unreadableDirectories: number
+  }
+  projects: ProjectReportEntry[]
+  notes: string[]
+}

package/cli/commands/report-issue.ts

@@ -1,27 +1,30 @@
 // peach report-issue — submit an explicitly approved compatibility report.
 
-import { existsSync, readFileSync } from 'node:fs'
+import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { getCliVersion } from '../../src/cli-version'
 import { readActiveRuntime } from '../../src/home-paths'
 import { authHeaderValue, resolveCliAuth } from '../auth'
 import { confirm } from '../prompt'
+import { installedManifest, readProjectManifest } from './detect'
+import {
+  createProjectReport,
+  formatProjectReport,
+  sanitizeProjectReportName,
+  sanitizeProjectReportVersion,
+} from './project-report'
+import type { ProjectReport } from './projectReportContract'
 import type { ScanResult } from '@peach/compat/web'
 
 const DEFAULT_REPORT_ORIGIN = 'https://contrast.dev'
 const MAX_DESCRIPTION_LENGTH = 8_000
 
-type PackageManifest = {
-  name?: string
-  dependencies?: Record<string, string>
-  devDependencies?: Record<string, string>
-}
-
 type ReportIssueOptions = {
   appDir: string
   description: string
   dryRun: boolean
   yes: boolean
+  scopeToApp: boolean
 }
 
 export type ReportIssuePayload = {
@@ -37,6 +40,7 @@ export type ReportIssuePayload = {
     platform: NodeJS.Platform
     arch: string
     compatibility: ScanResult | null
+    projectReport: ProjectReport
   }
 }
 
@@ -104,60 +108,38 @@ export function parseReportIssueOptions(
   return {
     appDir: resolve(cwd, app ?? '.'),
     description,
+    scopeToApp: app !== null,
     dryRun: args.includes('--dry-run'),
     yes: args.includes('--yes') || args.includes('-y'),
   }
 }
 
-function readStringRecord(value: unknown): Record<string, string> | undefined {
-  if (!value || typeof value !== 'object') return undefined
-  const output: Record<string, string> = {}
-  for (const key of Object.keys(value)) {
-    const next = Object.getOwnPropertyDescriptor(value, key)?.value
-    if (typeof next === 'string') output[key] = next
-  }
-  return output
-}
-
-function readManifest(appDir: string): PackageManifest | null {
-  const path = resolve(appDir, 'package.json')
-  if (!existsSync(path)) return null
-
-  let parsed: unknown
-  try {
-    parsed = JSON.parse(readFileSync(path, 'utf8'))
-  } catch {
-    throw new Error(`could not parse ${path}`)
-  }
-  if (!parsed || typeof parsed !== 'object') {
-    throw new Error(`${path} must contain a JSON object`)
-  }
-
-  const name = Object.getOwnPropertyDescriptor(parsed, 'name')?.value
-  const dependencies = Object.getOwnPropertyDescriptor(parsed, 'dependencies')?.value
-  const devDependencies = Object.getOwnPropertyDescriptor(
-    parsed,
-    'devDependencies',
-  )?.value
-  const dependencyRecord = readStringRecord(dependencies)
-  const devDependencyRecord = readStringRecord(devDependencies)
-  return {
-    ...(typeof name === 'string' ? { name } : {}),
-    ...(dependencyRecord ? { dependencies: dependencyRecord } : {}),
-    ...(devDependencyRecord ? { devDependencies: devDependencyRecord } : {}),
-  }
-}
-
 export async function createReportIssuePayload(
-  options: Pick<ReportIssueOptions, 'appDir' | 'description'>,
+  options: Pick<ReportIssueOptions, 'appDir' | 'description'> & { scopeToApp?: boolean },
   now = new Date(),
 ): Promise<ReportIssuePayload> {
-  const manifest = readManifest(options.appDir)
-  const compatibility = manifest
-    ? (await import('@peach/compat/web')).scanDeps(manifest)
+  const manifest = readProjectManifest(options.appDir)
+  const installed = manifest ? installedManifest(options.appDir, manifest) : null
+  const safeVersions = (deps: Record<string, string> | undefined) =>
+    deps &&
+    Object.fromEntries(
+      Object.entries(deps).map(([name, version]) => [
+        name,
+        sanitizeProjectReportVersion(version),
+      ]),
+    )
+  const compatibility = installed
+    ? (await import('@peach/compat/web')).scanDeps({
+        name: installed.name ? sanitizeProjectReportName(installed.name) : undefined,
+        dependencies: safeVersions(installed.dependencies),
+        devDependencies: safeVersions(installed.devDependencies),
+      })
+    : null
+  const cliVersion = sanitizeProjectReportVersion(getCliVersion())
+  const activeRuntime = readActiveRuntime()
+  const runtimeVersion = activeRuntime
+    ? sanitizeProjectReportVersion(activeRuntime)
     : null
-  const cliVersion = getCliVersion()
-  const runtimeVersion = readActiveRuntime()
 
   return {
     note: options.description,
@@ -175,6 +157,7 @@ export async function createReportIssuePayload(
       platform: process.platform,
       arch: process.arch,
       compatibility,
+      projectReport: createProjectReport(options.appDir, options.scopeToApp),
     },
   }
 }
@@ -243,7 +226,8 @@ export async function runReportIssue(
       `  environment: CLI ${payload.bundle.cliVersion}, runtime ${
         payload.bundle.runtimeVersion ?? 'not installed'
       }, ${payload.bundle.platform}/${payload.bundle.arch}\n\n` +
-      `  Includes only the description, compatibility scan, and the version/platform details above.\n` +
+      `${formatProjectReport(payload.bundle.projectReport)}\n` +
+      `  Includes only the description, compatibility scan, project/dependency metadata, and toolchain details above.\n` +
       `  It does not include source files, environment variables, terminal output, logs, screenshots, or app data.\n`,
   )
 
@@ -260,7 +244,7 @@ export async function runReportIssue(
       return 2
     }
     const approved = await dependencies.confirmSubmission(
-      'send this compatibility report to the peach team?',
+      'send this issue and project report to the peach team?',
       false,
     )
     if (!approved) {

package/cli/commands/setup.ts

@@ -17,6 +17,7 @@ import {
 } from '../../src/home-paths'
 import { rnxRuntime } from '../../src/runtime-delivery'
 import { findDesktopCompanion } from '../desktop-companion'
+import { canPromptForPrivacyChoice } from '../privacy'
 import { confirm, select } from '../prompt'
 import {
   applyRepositorySetup,
@@ -342,11 +343,12 @@ async function decidePrivacy(
 ): Promise<boolean> {
   if (options.productAnalytics !== undefined) return options.productAnalytics
   if (current.configured) return current.productAnalytics
-  if (options.yes || options.ci || !process.stdin.isTTY) return false
+  if (options.yes || options.ci || !canPromptForPrivacyChoice()) return false
   printPromptBlock('Private by default', [
-    'Diagnostics stay off unless you opt in.',
-    'Reports can contain package compatibility or an error class.',
-    'They never contain your code or app data.',
+    'Diagnostics stay off unless you opt in, including CI, pipes and agent runs. DO_NOT_TRACK overrides opt-in.',
+    'Reports include CLI/runtime versions, OS/arch, command name and a random install ID.',
+    'They include package incompatibilities, error classes and first-line error/warning messages (300 characters, paths redacted).',
+    'Reports exclude arguments, stacks, app source and structured app data.',
   ])
   return confirm('Share bounded diagnostics to improve peach?', false)
 }

package/cli/commands/telemetry.ts

@@ -2,8 +2,7 @@
 // product analytics preference shown by guided setup and Settings.
 //
 // this is the process-wide preference; `DO_NOT_TRACK=1` still forces opt-out
-// for a single run regardless of what's stored (honored by isOptedOut in
-// telemetry.ts, the same cross-tool signal npm/turbo/supabase use).
+// for a single run regardless of stored consent, including CI and agents.
 
 import {
   configFilePath,
@@ -16,7 +15,13 @@ function printStatus(): void {
   const preferences = readPrivacyPreferences()
   const enabled = preferences.configured && preferences.productAnalytics
   console.log(`  bounded diagnostics are ${enabled ? 'ON' : 'OFF'}`)
-  console.log('  permitted fields: package name/version/unsupported API or error class')
+  console.log('  fields: CLI/runtime versions, OS/arch, command name, random install ID')
+  console.log(
+    '  diagnostics: package name/version/unsupported API; error class and first-line error/warning messages (300 characters, paths redacted)',
+  )
+  console.log(
+    '  explicit opt-in also applies in CI, pipes and agent runs; DO_NOT_TRACK wins',
+  )
   console.log(`  config: ${configFilePath()}`)
   const doNotTrack = process.env.DO_NOT_TRACK
   if (doNotTrack === '1' || doNotTrack === 'true') {