helloagents 3.0.32 → 3.0.35

package/scripts/project-session-cleanup.mjs

@@ -1,19 +1,18 @@
-import { existsSync, readdirSync, rmSync } from 'node:fs'
+import { existsSync, readdirSync, rmSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 
 import {
   ACTIVE_SESSION_FILE_NAME,
-  CAPSULE_FILE_NAME,
-  EVENTS_FILE_NAME,
-  PROJECT_ARTIFACTS_DIR_NAME,
   PROJECT_SESSIONS_DIR_NAME,
   getProjectActivationDir,
   getProjectRoot,
   readJsonFile,
   writeJsonFileAtomic,
 } from './runtime-scope.mjs'
+import { LONG_RUNNING_TTL_MS } from './runtime-ttl.mjs'
 
 export const PROJECT_SESSION_CLEANUP_COOLDOWN_MS = 10 * 60 * 1000
+export const PROJECT_SESSION_MAX_AGE_MS = LONG_RUNNING_TTL_MS
 
 function removePath(filePath, result, bucket) {
   try {
@@ -33,29 +32,6 @@ function isDirectoryEmptyRecursive(dirPath) {
   })
 }
 
-function listFilesRecursive(dirPath) {
-  const entries = readdirSync(dirPath, { withFileTypes: true })
-  return entries.flatMap((entry) => {
-    const entryPath = join(dirPath, entry.name)
-    if (entry.isDirectory()) {
-      return listFilesRecursive(entryPath).map((child) => `${entry.name}/${child}`)
-    }
-    return entry.isFile() ? [entry.name] : []
-  })
-}
-
-function isRouteOnlySessionDir(sessionDir) {
-  if (existsSync(join(sessionDir, 'STATE.md'))) return false
-  const files = listFilesRecursive(sessionDir).map((file) => file.replace(/\\/g, '/'))
-  if (files.length === 0) return false
-  if (!files.includes(`${PROJECT_ARTIFACTS_DIR_NAME}/codex-native-stop.json`)) return false
-  return files.every((file) => [
-    CAPSULE_FILE_NAME,
-    EVENTS_FILE_NAME,
-    `${PROJECT_ARTIFACTS_DIR_NAME}/codex-native-stop.json`,
-  ].includes(file))
-}
-
 function shouldKeepSession(active, workspace, session) {
   const activeWorkspace = active.workspace || active.branch || ''
   return activeWorkspace === workspace && active.session === session
@@ -75,7 +51,35 @@ function writeCleanupCheckpoint(activePath, active, now) {
   })
 }
 
-export function cleanupProjectSessions(cwd, { now = Date.now(), minIntervalMs = 0 } = {}) {
+function hasStateSnapshot(sessionDir) {
+  return existsSync(join(sessionDir, 'STATE.md'))
+}
+
+function readSessionStateMtimeMs(sessionDir) {
+  try {
+    return statSync(join(sessionDir, 'STATE.md')).mtimeMs
+  } catch {
+    return 0
+  }
+}
+
+function isStaleStateSession(sessionDir, now, maxAgeMs) {
+  const mtimeMs = readSessionStateMtimeMs(sessionDir)
+  return !Number.isFinite(mtimeMs) || mtimeMs <= 0 || (now - mtimeMs > maxAgeMs)
+}
+
+function isTransientSessionTemp(entryName = '') {
+  return /^\.[0-9]+-[0-9a-f-]+\.tmp$/i.test(entryName)
+}
+
+function cleanupTransientSessionTemps(sessionsDir, result) {
+  for (const entry of readdirSync(sessionsDir, { withFileTypes: true })) {
+    if (!entry.isFile() || !isTransientSessionTemp(entry.name)) continue
+    removePath(join(sessionsDir, entry.name), result, 'removedTempFiles')
+  }
+}
+
+export function cleanupProjectSessions(cwd, { now = Date.now(), minIntervalMs = 0, maxAgeMs = PROJECT_SESSION_MAX_AGE_MS } = {}) {
   const projectRoot = getProjectRoot(cwd)
   const activationDir = getProjectActivationDir(projectRoot)
   const sessionsDir = join(activationDir, PROJECT_SESSIONS_DIR_NAME)
@@ -84,7 +88,9 @@ export function cleanupProjectSessions(cwd, { now = Date.now(), minIntervalMs =
   const result = {
     sessionsDir,
     removedEmptyDirs: [],
-    removedRouteOnlyDirs: [],
+    removedInactiveDirs: [],
+    removedNoStateDirs: [],
+    removedTempFiles: [],
     errors: [],
     skipped: false,
   }
@@ -98,6 +104,12 @@ export function cleanupProjectSessions(cwd, { now = Date.now(), minIntervalMs =
     }
   }
 
+  try {
+    cleanupTransientSessionTemps(sessionsDir, result)
+  } catch (error) {
+    result.errors.push(`${sessionsDir}: ${error.message}`)
+  }
+
   for (const workspaceEntry of readdirSync(sessionsDir, { withFileTypes: true })) {
     if (!workspaceEntry.isDirectory()) continue
     const workspaceDir = join(sessionsDir, workspaceEntry.name)
@@ -110,8 +122,10 @@ export function cleanupProjectSessions(cwd, { now = Date.now(), minIntervalMs =
       try {
         if (isDirectoryEmptyRecursive(sessionDir)) {
           removePath(sessionDir, result, 'removedEmptyDirs')
-        } else if (isRouteOnlySessionDir(sessionDir)) {
-          removePath(sessionDir, result, 'removedRouteOnlyDirs')
+        } else if (!hasStateSnapshot(sessionDir)) {
+          removePath(sessionDir, result, 'removedNoStateDirs')
+        } else if (isStaleStateSession(sessionDir, now, maxAgeMs)) {
+          removePath(sessionDir, result, 'removedInactiveDirs')
         }
       } catch (error) {
         result.errors.push(`${sessionDir}: ${error.message}`)

package/scripts/qa-review-state.mjs

@@ -0,0 +1,313 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import { appendReplayEvent } from './replay-state.mjs'
+import {
+  captureWorkspaceFingerprint,
+  clearRuntimeEvidence,
+  getRuntimeEvidencePath,
+  getRuntimeEvidenceRelativePath,
+  readRuntimeEvidence,
+  validateEvidenceFingerprint,
+  validateEvidenceTimestamp,
+  writeRuntimeEvidence,
+} from './runtime-artifacts.mjs'
+import { getProjectVerifyYamlPath } from './project-storage.mjs'
+
+export const QA_REVIEW_EVIDENCE_FILE_NAME = 'qa-review.json'
+const VALID_QA_MODES = new Set(['standard', 'deep'])
+const VALID_QA_OUTCOMES = new Set(['clean', 'findings'])
+const SHELL_OPERATORS = /[;&|`$(){}\n\r]/
+
+function normalizeStringArray(values) {
+  if (!Array.isArray(values)) return []
+  return [...new Set(values
+    .map((value) => (typeof value === 'string' ? value.trim() : ''))
+    .filter(Boolean))]
+}
+
+function normalizeQaMode(value) {
+  const normalized = typeof value === 'string' ? value.trim().toLowerCase() : ''
+  return VALID_QA_MODES.has(normalized) ? normalized : ''
+}
+
+function normalizeQaOutcome(value) {
+  const normalized = typeof value === 'string' ? value.trim().toLowerCase() : ''
+  return VALID_QA_OUTCOMES.has(normalized) ? normalized : ''
+}
+
+function normalizeCommands(values) {
+  return normalizeStringArray(values)
+}
+
+function loadVerifyYaml(cwd) {
+  const filePath = getProjectVerifyYamlPath(cwd)
+  if (!existsSync(filePath)) return null
+  try {
+    const content = readFileSync(filePath, 'utf-8')
+    const commands = []
+    let inCommands = false
+    for (const line of content.split('\n')) {
+      const trimmed = line.trim()
+      if (trimmed.startsWith('commands:')) {
+        inCommands = true
+        continue
+      }
+      if (!inCommands) continue
+      if (trimmed.startsWith('- ') && !trimmed.startsWith('# ')) {
+        const command = trimmed.slice(2).trim().replace(/^["']|["']$/g, '')
+        if (command && !command.startsWith('#')) commands.push(command)
+        continue
+      }
+      if (trimmed && !trimmed.startsWith('#')) break
+    }
+    return commands.length > 0 ? commands : null
+  } catch {
+    return null
+  }
+}
+
+function detectFromPackageJson(cwd) {
+  const filePath = join(cwd, 'package.json')
+  if (!existsSync(filePath)) return []
+  try {
+    const scripts = JSON.parse(readFileSync(filePath, 'utf-8')).scripts || {}
+    return ['lint', 'typecheck', 'type-check', 'test', 'build']
+      .filter((key) => key in scripts)
+      .map((key) => `npm run ${key}`)
+  } catch {
+    return []
+  }
+}
+
+function detectFromPyproject(cwd) {
+  const filePath = join(cwd, 'pyproject.toml')
+  if (!existsSync(filePath)) return []
+  try {
+    const content = readFileSync(filePath, 'utf-8')
+    const commands = []
+    if (content.includes('[tool.ruff')) commands.push('ruff check .')
+    if (content.includes('[tool.mypy')) commands.push('mypy .')
+    if (content.includes('[tool.pytest')) commands.push('pytest --tb=short -q')
+    return commands
+  } catch {
+    return []
+  }
+}
+
+export function detectCommands(cwd) {
+  const yamlCommands = loadVerifyYaml(cwd)
+  if (yamlCommands?.length) return yamlCommands
+  const packageJsonCommands = detectFromPackageJson(cwd)
+  if (packageJsonCommands.length > 0) return packageJsonCommands
+  return detectFromPyproject(cwd)
+}
+
+export function hasUnsafeQaCommand(commands = []) {
+  return commands.some((command) => SHELL_OPERATORS.test(command))
+}
+
+export function getQaReviewEvidencePath(cwd, options = {}) {
+  return getRuntimeEvidencePath(cwd, QA_REVIEW_EVIDENCE_FILE_NAME, options)
+}
+
+export function readQaReviewEvidence(cwd, options = {}) {
+  return readRuntimeEvidence(cwd, QA_REVIEW_EVIDENCE_FILE_NAME, options)
+}
+
+export function clearQaReviewEvidence(cwd, options = {}) {
+  clearRuntimeEvidence(cwd, QA_REVIEW_EVIDENCE_FILE_NAME, options)
+}
+
+export function normalizeQaReviewEvidence(input = {}) {
+  return {
+    source: typeof input.source === 'string' && input.source.trim() ? input.source.trim() : 'manual',
+    originCommand: typeof input.originCommand === 'string' ? input.originCommand.trim() : '',
+    qaMode: normalizeQaMode(input.qaMode) || 'standard',
+    scope: typeof input.scope === 'string' ? input.scope.trim() : '',
+    outcome: normalizeQaOutcome(input.outcome),
+    conclusion: typeof input.conclusion === 'string' ? input.conclusion.trim() : '',
+    findings: normalizeStringArray(input.findings),
+    fileReferences: normalizeStringArray(input.fileReferences),
+    commands: normalizeCommands(input.commands),
+    fastOnly: Boolean(input.fastOnly),
+  }
+}
+
+export function writeQaReviewEvidence(cwd, {
+  source = 'manual',
+  originCommand = '',
+  qaMode = 'standard',
+  scope = '',
+  outcome = '',
+  conclusion = '',
+  findings = [],
+  fileReferences = [],
+  commands = [],
+  fastOnly = false,
+} = {}, options = {}) {
+  const normalized = normalizeQaReviewEvidence({
+    source,
+    originCommand,
+    qaMode,
+    scope,
+    outcome,
+    conclusion,
+    findings,
+    fileReferences,
+    commands,
+    fastOnly,
+  })
+  const payload = {
+    schemaVersion: 2,
+    updatedAt: new Date().toISOString(),
+    source: normalized.source,
+    originCommand: normalized.originCommand,
+    qaMode: normalized.qaMode,
+    scope: normalized.scope,
+    outcome: normalized.outcome,
+    conclusion: normalized.conclusion,
+    findings: normalized.findings,
+    fileReferences: normalized.fileReferences,
+    commands: normalized.commands,
+    fastOnly: normalized.fastOnly,
+    fingerprint: captureWorkspaceFingerprint(cwd),
+  }
+  writeRuntimeEvidence(cwd, QA_REVIEW_EVIDENCE_FILE_NAME, payload, options)
+  appendReplayEvent(cwd, {
+    event: 'qa_review_evidence_written',
+    source: normalized.source,
+    skillName: normalized.originCommand,
+    payload: options.payload || {},
+    details: {
+      qaMode: normalized.qaMode,
+      scope: normalized.scope,
+      outcome: normalized.outcome,
+      conclusion: normalized.conclusion,
+      findings: normalized.findings,
+      fileReferences: normalized.fileReferences,
+      commands: normalized.commands,
+      fastOnly: normalized.fastOnly,
+    },
+    artifacts: [getRuntimeEvidenceRelativePath(cwd, QA_REVIEW_EVIDENCE_FILE_NAME, options)],
+  })
+  return payload
+}
+
+function readRequiredQaReviewEvidence(cwd, options = {}) {
+  const evidence = readQaReviewEvidence(cwd, options)
+  if (evidence) return { evidence }
+  return {
+    error: {
+      required: true,
+      status: 'missing',
+      details: ['缺少当前工作流的成功 qa-review 证据'],
+    },
+  }
+}
+
+function validateQaReviewTimestamp(evidence, now) {
+  return validateEvidenceTimestamp(evidence, now, 'qa-review 证据')
+}
+
+function validateQaReviewFingerprint(cwd, evidence) {
+  return validateEvidenceFingerprint(cwd, evidence, '成功 qa-review 证据')
+}
+
+function validateQaReviewEvidence(commands, evidence) {
+  if (!normalizeQaOutcome(evidence.outcome) || !String(evidence.conclusion || '').trim()) {
+    return {
+      required: true,
+      status: 'invalid',
+      evidence,
+      commands,
+      details: ['qa-review 证据必须记录明确的 outcome 和 conclusion'],
+    }
+  }
+  if (commands.length > 0 && normalizeCommands(evidence.commands).length === 0) {
+    return {
+      required: true,
+      status: 'invalid',
+      evidence,
+      commands,
+      details: ['qa-review 证据必须记录本次实际执行的验证命令'],
+    }
+  }
+  if (Boolean(evidence.fastOnly)) {
+    return {
+      required: true,
+      status: 'fast-only',
+      evidence,
+      commands,
+      details: ['最新 qa-review 证据只覆盖快速命令检查，未完成完整 qa-review 闭环'],
+    }
+  }
+  if (normalizeQaOutcome(evidence.outcome) !== 'clean') {
+    return {
+      required: true,
+      status: 'blocked',
+      evidence,
+      commands,
+      details: ['最新 qa-review 证据仍记录阻断问题'],
+    }
+  }
+  return null
+}
+
+export function getQaReviewEvidenceStatus(cwd, { required = false, now = Date.now(), ...options } = {}) {
+  const commands = detectCommands(cwd)
+  if (!required) {
+    return {
+      required: false,
+      status: 'not-applicable',
+      commands,
+    }
+  }
+
+  const requiredEvidence = readRequiredQaReviewEvidence(cwd, options)
+  if (requiredEvidence.error) return { ...requiredEvidence.error, commands }
+
+  const { evidence } = requiredEvidence
+  const timestampError = validateQaReviewTimestamp(evidence, now)
+  if (timestampError) return { ...timestampError, commands }
+
+  const fingerprintError = validateQaReviewFingerprint(cwd, evidence)
+  if (fingerprintError) return { ...fingerprintError, commands }
+
+  const evidenceError = validateQaReviewEvidence(commands, evidence)
+  if (evidenceError) return evidenceError
+
+  return {
+    required: true,
+    status: 'valid',
+    evidence,
+    commands,
+  }
+}
+
+function readStdinJson() {
+  try {
+    return JSON.parse(readFileSync(0, 'utf-8'))
+  } catch {
+    return {}
+  }
+}
+
+function main() {
+  const command = process.argv[2] || ''
+  if (command !== 'write') return
+
+  const input = readStdinJson()
+  const cwd = input.cwd || process.cwd()
+  const payload = writeQaReviewEvidence(cwd, input, { payload: input })
+  process.stdout.write(JSON.stringify({
+    suppressOutput: true,
+    path: getQaReviewEvidencePath(cwd, { payload: input }),
+    payload,
+  }))
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
+  main()
+}

package/scripts/ralph-loop.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * HelloAGENTS Ralph Loop — Quality verification gate
+ * HelloAGENTS QA Gate — Quality verification gate
  * Runs on SubagentStop (Claude Code) and Stop (Codex CLI).
  * Auto-detects lint/test commands and blocks if they fail.
  */
@@ -9,7 +9,13 @@ import { join } from 'node:path';
 import { execSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
-import { clearVerifyEvidence, detectCommands, hasUnsafeVerifyCommand, writeVerifyEvidence } from './verify-state.mjs';
+import {
+  clearQaReviewEvidence,
+  detectCommands,
+  getQaReviewEvidenceStatus,
+  hasUnsafeQaCommand,
+  writeQaReviewEvidence,
+} from './qa-review-state.mjs';
 import {
   getRuntimeEvidencePath,
   readRuntimeEvidence,
@@ -70,7 +76,7 @@ function hasGitChanges(cwd) {
 function runVerify(commands, cwd) {
   const failures = [];
   for (const cmd of commands) {
-    if (hasUnsafeVerifyCommand([cmd])) {
+    if (hasUnsafeQaCommand([cmd])) {
       failures.push({ cmd, output: '已阻止：验证命令不允许使用 shell 组合操作符' });
       continue;
     }
@@ -98,6 +104,59 @@ function getLastAssistantMessage(data = {}) {
   ).trim();
 }
 
+function hasTruthyAgentFlag(value) {
+  if (typeof value === 'boolean') return value;
+  const normalized = String(value || '').trim().toLowerCase();
+  return ['1', 'true', 'yes', 'subagent'].includes(normalized);
+}
+
+function hasNonEmptyValue(value) {
+  return String(value || '').trim().length > 0;
+}
+
+function looksLikeCodexDelegatedTurn(data = {}) {
+  if (!data || typeof data !== 'object') return false;
+  const client = String(data.client || '').trim();
+  const inputMessages = Array.isArray(data.inputMessages) ? data.inputMessages : [];
+  return !client && inputMessages.length > 1;
+}
+
+function inferSubagentFromPayload(data = {}) {
+  if (!data || typeof data !== 'object') return false;
+
+  if ([data.isSubagent, data.subagent].some(hasTruthyAgentFlag)) {
+    return true;
+  }
+
+  const roleLike = [
+    data.role,
+    data.agentRole,
+    data.agent_role,
+    data.agentKind,
+    data.agent_kind,
+    data.kind,
+  ]
+    .map((value) => String(value || '').trim().toLowerCase())
+    .filter(Boolean);
+
+  if (roleLike.some((value) => ['subagent', 'delegate', 'delegated', 'worker', 'explorer'].includes(value))) {
+    return true;
+  }
+
+  if ([
+    data.parentAgentId,
+    data.parent_agent_id,
+    data.parentTurnId,
+    data.parent_turn_id,
+    data.delegatedByAgentId,
+    data.delegated_by_agent_id,
+  ].some(hasNonEmptyValue)) {
+    return true;
+  }
+
+  return looksLikeCodexDelegatedTurn(data);
+}
+
 function hasHelloagentsWrapper(message = '') {
   if (!message.includes('【HelloAGENTS】')) return false;
   const firstNonEmptyLine = message
@@ -138,7 +197,7 @@ export function evaluateRalphLoop(data = {}, runtime = {}) {
 
   const cwd = data.cwd || process.cwd();
   const runtimeOptions = { payload: data };
-  const isSubagent = runtime.isSubagent ?? IS_SUBAGENT;
+  const isSubagent = runtime.isSubagent === true || inferSubagentFromPayload(data) || IS_SUBAGENT;
   const hookEventName = runtime.hookEventName || HOOK_EVENT;
 
   if (isSubagent) {
@@ -166,17 +225,30 @@ export function evaluateRalphLoop(data = {}, runtime = {}) {
   const failures = runVerify(commands, cwd);
   if (failures.length === 0) {
     resetBreaker(cwd, runtimeOptions);
-    writeVerifyEvidence(cwd, {
-      commands: detectCommands(cwd),
-      fastOnly: isSubagent,
-      source: isSubagent ? 'subagent' : 'stop',
-    }, runtimeOptions);
+    const qaStatus = getQaReviewEvidenceStatus(cwd, {
+      required: true,
+      ...runtimeOptions,
+    });
+    if (qaStatus.status !== 'valid') {
+      writeQaReviewEvidence(cwd, {
+        source: isSubagent ? 'subagent' : 'ralph-loop',
+        originCommand: 'qa',
+        qaMode: 'standard',
+        scope: isSubagent ? 'subagent-fast-check' : 'runtime-fast-check',
+        outcome: 'clean',
+        conclusion: '自动命令检查通过。',
+        findings: [],
+        fileReferences: [],
+        commands: detectCommands(cwd),
+        fastOnly: true,
+      }, runtimeOptions);
+    }
 
     if (isSubagent) {
       return {
         hookSpecificOutput: {
           hookEventName,
-          additionalContext: '子代理快速验证通过（lint/typecheck）。请控制器审查变更后继续。',
+          additionalContext: '子代理快速 QA 命令检查通过（lint/typecheck）。请控制器继续完整 qa-review。',
         },
         suppressOutput: true,
       };
@@ -186,7 +258,7 @@ export function evaluateRalphLoop(data = {}, runtime = {}) {
       return {
         hookSpecificOutput: {
           hookEventName,
-          additionalContext: '⚠️ [Ralph Loop] 验证通过但未检测到代码变更（git diff 为空）。如果确实完成了编码任务，请确认变更已保存。',
+          additionalContext: '⚠️ [QA Gate] 验证通过但未检测到代码变更（git diff 为空）。如果确实完成了编码任务，请确认变更已保存。',
         },
         suppressOutput: true,
       };
@@ -195,7 +267,7 @@ export function evaluateRalphLoop(data = {}, runtime = {}) {
     return { suppressOutput: true };
   }
 
-  clearVerifyEvidence(cwd, runtimeOptions);
+  clearQaReviewEvidence(cwd, runtimeOptions);
   const breaker = readBreaker(cwd, runtimeOptions);
   breaker.consecutive_failures += 1;
   breaker.last_failure = new Date().toISOString();
@@ -207,7 +279,7 @@ export function evaluateRalphLoop(data = {}, runtime = {}) {
   const details = failures.map(f => `\u2717 ${f.cmd}\n${f.output}`).join('\n\n');
   return {
     decision: 'block',
-    reason: `[Ralph Loop] 验证失败：\n\n${details}\n\n请先修复以上问题，再报告完成。${breakerWarning}`,
+    reason: `[QA Gate] 验证失败：\n\n${details}\n\n请先修复以上问题，再报告完成。${breakerWarning}`,
     suppressOutput: true,
   };
 }
@@ -225,7 +297,7 @@ if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
   } catch (error) {
     process.stdout.write(JSON.stringify({
       decision: 'block',
-      reason: `[Ralph Loop] 验证脚本执行异常，已暂停完成通知。\n原因：${error?.message || error}`,
+      reason: `[QA Gate] 验证脚本执行异常，已暂停完成通知。\n原因：${error?.message || error}`,
       suppressOutput: true,
     }));
   }

package/scripts/runtime-scope.mjs

@@ -12,7 +12,6 @@ import { FULL_CARRIER_PROFILE_MARKER } from './cli-utils.mjs'
 export const PROJECT_DIR_NAME = '.helloagents'
 export const PROJECT_SESSIONS_DIR_NAME = 'sessions'
 export const PROJECT_ARTIFACTS_DIR_NAME = 'artifacts'
-export const CAPSULE_FILE_NAME = 'capsule.json'
 export const EVENTS_FILE_NAME = 'events.jsonl'
 export const ACTIVE_SESSION_FILE_NAME = 'active.json'
 export const DEFAULT_STATE_SESSION_TOKEN = 'default'
@@ -463,7 +462,6 @@ export function getProjectSessionScope(cwd, options = {}) {
     activationDir,
     sessionDir,
     statePath: join(sessionDir, 'STATE.md'),
-    capsulePath: join(sessionDir, CAPSULE_FILE_NAME),
     eventsPath: join(sessionDir, EVENTS_FILE_NAME),
     artifactsDir: join(sessionDir, PROJECT_ARTIFACTS_DIR_NAME),
     key: `${projectRoot}::${workspace}::${session}`,
@@ -493,7 +491,7 @@ function buildTransientRuntimeDir(cwd, options = {}) {
     session: token,
     sessionMode: token === DEFAULT_STATE_SESSION_TOKEN ? 'default' : 'transient-session',
     sessionDir: join(getUserRuntimeRoot(), hash),
-    capsulePath: join(getUserRuntimeRoot(), hash, CAPSULE_FILE_NAME),
+    statePath: join(getUserRuntimeRoot(), hash, 'STATE.md'),
     eventsPath: join(getUserRuntimeRoot(), hash, EVENTS_FILE_NAME),
     artifactsDir: join(getUserRuntimeRoot(), hash, PROJECT_ARTIFACTS_DIR_NAME),
     key: `${normalizedCwd}::transient::${token}`,