@openprd/cli 0.1.18 → 0.1.21

package/src/context/constants.js

@@ -0,0 +1,30 @@
+export const CONTEXT_REQUEST_SCHEMA_VERSION = 'openprd.context-request.v1';
+export const CONTEXT_CAPSULE_SCHEMA_VERSION = 'openprd.context-capsule.v1';
+export const CONTEXT_CACHE_SCHEMA_VERSION = 'openprd.context-cache-entry.v1';
+export const CONTEXT_TELEMETRY_SCHEMA_VERSION = 'openprd.context-telemetry.v1';
+
+export const CONTEXT_COMPILER_VERSION = '1.0.0';
+export const DEFAULT_CONTEXT_TOKEN_BUDGET = 800;
+export const DEFAULT_CONTEXT_DELTA_TOKEN_BUDGET = 250;
+
+// Authority is intentionally explicit. Callers can still provide a numeric score,
+// but named values keep cross-tool adapters aligned on the same precedence rules.
+export const CONTEXT_AUTHORITY_SCORES = Object.freeze({
+  'user-confirmed': 100,
+  'project-canonical': 90,
+  'runtime-observed': 80,
+  'project-derived': 70,
+  'tool-derived': 60,
+  'agent-inferred': 40,
+  external: 30,
+  unknown: 0,
+});
+
+export const CONTEXT_FRESHNESS_SCORES = Object.freeze({
+  current: 4,
+  latest: 3,
+  recent: 2,
+  historical: 1,
+  stale: 0,
+  unknown: 0,
+});

package/src/context/index.js

@@ -0,0 +1,39 @@
+export {
+  CONTEXT_AUTHORITY_SCORES,
+  CONTEXT_CACHE_SCHEMA_VERSION,
+  CONTEXT_CAPSULE_SCHEMA_VERSION,
+  CONTEXT_COMPILER_VERSION,
+  CONTEXT_FRESHNESS_SCORES,
+  CONTEXT_REQUEST_SCHEMA_VERSION,
+  CONTEXT_TELEMETRY_SCHEMA_VERSION,
+  DEFAULT_CONTEXT_DELTA_TOKEN_BUDGET,
+  DEFAULT_CONTEXT_TOKEN_BUDGET,
+} from './constants.js';
+
+export {
+  buildContextRequestFingerprint,
+  compileContextCapsule,
+  computeContextCapsuleDigest,
+  createContextRequest,
+  verifyContextCapsule,
+} from './compiler.js';
+
+export {
+  buildContextCacheKey,
+  compileContextWithCache,
+  contextCachePath,
+  createFileContextCache,
+  createMemoryContextCache,
+  invalidateContextCache,
+  readContextCache,
+  runContextCacheBenchmark,
+  writeContextCache,
+} from './cache.js';
+
+export {
+  createContextTelemetryEvent,
+  emitContextTelemetry,
+} from './telemetry.js';
+
+export { redactContextSecrets } from './redaction.js';
+export { digestStable, digestText, stableStringify } from './stable.js';

package/src/context/redaction.js

@@ -0,0 +1,84 @@
+const SECRET_KEY_PATTERN = /^(?:[a-z0-9]+[_-])*(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|auth(?:orization)?|client[_-]?secret|password|passwd|secret|private[_-]?key)$/i;
+
+const TEXT_PATTERNS = [
+  {
+    reason: 'private-key',
+    pattern: /-----BEGIN(?: [A-Z0-9]+)? PRIVATE KEY-----[\s\S]*?-----END(?: [A-Z0-9]+)? PRIVATE KEY-----/g,
+    replacement: '[REDACTED:PRIVATE_KEY]',
+  },
+  {
+    reason: 'bearer-token',
+    pattern: /(\bBearer\s+)[A-Za-z0-9._~+/=-]{8,}/gi,
+    replacement: '$1[REDACTED]',
+  },
+  {
+    reason: 'credential-assignment',
+    pattern: /(\b(?:[a-z0-9]+[_-])*(?:api[_-]?key|access[_-]?token|refresh[_-]?token|token|authorization|client[_-]?secret|password|passwd|secret)\b\s*[:=]\s*)(?:"[^"]*"|'[^']*'|[^\s,;]+)/gi,
+    replacement: '$1[REDACTED]',
+  },
+  {
+    reason: 'provider-token',
+    pattern: /\b(?:sk-(?:proj-)?|gh[pousr]_|xox[baprs]-)[A-Za-z0-9_-]{8,}\b/g,
+    replacement: '[REDACTED:TOKEN]',
+  },
+  {
+    reason: 'jwt',
+    pattern: /\beyJ[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\b/g,
+    replacement: '[REDACTED:JWT]',
+  },
+  {
+    reason: 'url-credential',
+    pattern: /:\/\/[^/\s:@]+:[^@\s/]+@/g,
+    replacement: '://[REDACTED]@',
+  },
+];
+
+function redactText(text, path, redactions) {
+  let output = String(text);
+  for (const item of TEXT_PATTERNS) {
+    output = output.replace(item.pattern, (...args) => {
+      redactions.push({ path, reason: item.reason });
+      if (typeof item.replacement === 'function') {
+        return item.replacement(...args);
+      }
+      return item.replacement.replace(/\$(\d+)/g, (_, index) => args[Number(index)] ?? '');
+    });
+  }
+  return output;
+}
+
+function redactValue(value, path, redactions, seen) {
+  if (typeof value === 'string') {
+    return redactText(value, path, redactions);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item, index) => redactValue(item, `${path}[${index}]`, redactions, seen));
+  }
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+  if (seen.has(value)) {
+    throw new TypeError('Context values must not contain circular references.');
+  }
+  seen.add(value);
+  const output = {};
+  for (const key of Object.keys(value).sort()) {
+    const childPath = path ? `${path}.${key}` : key;
+    if (SECRET_KEY_PATTERN.test(key)) {
+      output[key] = '[REDACTED]';
+      redactions.push({ path: childPath, reason: 'secret-field' });
+      continue;
+    }
+    output[key] = redactValue(value[key], childPath, redactions, seen);
+  }
+  seen.delete(value);
+  return output;
+}
+
+export function redactContextSecrets(value) {
+  const redactions = [];
+  return {
+    value: redactValue(value, '$', redactions, new WeakSet()),
+    redactions,
+  };
+}

package/src/context/stable.js

@@ -0,0 +1,69 @@
+import { createHash } from 'node:crypto';
+
+function normalizeStableValue(value, seen = new WeakSet()) {
+  if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+    return value;
+  }
+  if (typeof value === 'number') {
+    return Number.isFinite(value) ? value : String(value);
+  }
+  if (typeof value === 'bigint') {
+    return value.toString();
+  }
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    if (seen.has(value)) {
+      throw new TypeError('Context values must not contain circular references.');
+    }
+    seen.add(value);
+    const normalized = value.map((item) => (
+      item === undefined || typeof item === 'function' || typeof item === 'symbol'
+        ? null
+        : normalizeStableValue(item, seen)
+    ));
+    seen.delete(value);
+    return normalized;
+  }
+  if (typeof value !== 'object' || value === undefined) {
+    return null;
+  }
+  if (seen.has(value)) {
+    throw new TypeError('Context values must not contain circular references.');
+  }
+  seen.add(value);
+  const normalized = {};
+  for (const key of Object.keys(value).sort()) {
+    const item = value[key];
+    if (item === undefined || typeof item === 'function' || typeof item === 'symbol') {
+      continue;
+    }
+    normalized[key] = normalizeStableValue(item, seen);
+  }
+  seen.delete(value);
+  return normalized;
+}
+
+export function stableStringify(value) {
+  return JSON.stringify(normalizeStableValue(value));
+}
+
+export function digestText(value) {
+  return `sha256:${createHash('sha256').update(String(value)).digest('hex')}`;
+}
+
+export function digestStable(value) {
+  return digestText(stableStringify(value));
+}
+
+export function compareStableText(left, right) {
+  const a = String(left ?? '');
+  const b = String(right ?? '');
+  if (a === b) return 0;
+  return a < b ? -1 : 1;
+}
+
+export function cloneStable(value) {
+  return JSON.parse(stableStringify(value));
+}

package/src/context/telemetry.js

@@ -0,0 +1,42 @@
+import { CONTEXT_TELEMETRY_SCHEMA_VERSION } from './constants.js';
+
+export function createContextTelemetryEvent({
+  capsule,
+  cacheStatus = 'not-used',
+  eventType = 'context.compiled',
+} = {}) {
+  if (!capsule?.digest) {
+    throw new TypeError('Context telemetry requires a compiled capsule.');
+  }
+  return {
+    schemaVersion: CONTEXT_TELEMETRY_SCHEMA_VERSION,
+    eventType,
+    requestDigest: capsule.requestDigest,
+    capsuleDigest: capsule.digest,
+    workspaceId: capsule.workspaceId,
+    revision: capsule.revision,
+    taskId: capsule.taskId,
+    delivery: capsule.delivery,
+    cacheStatus,
+    metrics: {
+      candidateCount: capsule.summary.candidateCount,
+      includedCount: capsule.summary.includedCount,
+      excludedCount: capsule.summary.excludedCount,
+      redactionCount: capsule.summary.redactionCount,
+      estimatedTokens: capsule.budget.estimatedTokens,
+      limitTokens: capsule.budget.limitTokens,
+    },
+  };
+}
+
+export async function emitContextTelemetry(sink, event) {
+  if (typeof sink === 'function') {
+    await sink(event);
+    return;
+  }
+  if (sink && typeof sink.record === 'function') {
+    await sink.record(event);
+    return;
+  }
+  throw new TypeError('Context telemetry sink must be a function or expose record().');
+}

package/src/dev-standards.js

@@ -87,6 +87,11 @@ const UI_FILE_EXTENSIONS = new Set([
 ]);
 const VISUAL_REVIEWS_DIR = cjoin('.openprd', 'harness', 'visual-reviews');
 const VISUAL_EVIDENCE_FRESH_MS = 24 * 60 * 60 * 1000;
+const I18N_CONFIG_PATH = cjoin('.openprd', 'i18n-config.json');
+const I18N_TEXT_FILE_EXTENSIONS = new Set([
+  '.html', '.jsx', '.swift', '.tsx', '.vue', '.wxml', '.svelte',
+  '.kt', '.java', '.dart', '.xml',
+]);
 
 function normalizePathForReport(value) {
   return String(value ?? '').split(path.sep).join('/');
@@ -461,12 +466,42 @@ async function buildVisualEvidenceReminder(projectRoot, files) {
     suggestedCommands: [
       'openprd visual-compare . --before <改前截图> --after <改后截图>',
       'openprd visual-compare . --board <alignment-board.json>（同构列表/卡片/网格/表格对齐，含容器轨道与内容槽位）',
+      '网格与基线只进入 alignment-board；普通结果画布不得自动叠加',
       'openprd visual-compare . --board <centering-board.json>（单素材内部居中/视觉重心）',
     ],
     chatEmbedHint: '生成后把证据图用 `![视觉证据](<输出路径>)` 直接嵌入最终回复，让用户在对话流里看到对齐效果。',
   };
 }
 
+async function buildI18nReminder(projectRoot, files) {
+  const textFiles = files
+    .filter((f) => f.status !== 'error' && I18N_TEXT_FILE_EXTENSIONS.has(path.extname(f.path).toLowerCase()))
+    .map((f) => f.path);
+  if (textFiles.length === 0) {
+    return { required: false, textFiles: [] };
+  }
+  const configPath = cjoin(projectRoot, I18N_CONFIG_PATH);
+  const config = await readJson(configPath).catch(() => null);
+  if (config && config.enforceOnDevCheck === false) {
+    return { required: false, textFiles, reason: 'i18n 检查已被用户关闭 (enforceOnDevCheck: false)。' };
+  }
+  const defaultLang = config?.defaultLanguage ?? 'zh-Hans';
+  const supported = Array.isArray(config?.supportedLanguages) ? config.supportedLanguages : ['zh-Hans', 'en'];
+  const platforms = Array.isArray(config?.platforms) ? config.platforms : [];
+  return {
+    required: true,
+    textFiles,
+    defaultLanguage: defaultLang,
+    supportedLanguages: supported,
+    platforms,
+    configExists: config !== null,
+    reason: config
+      ? `本轮触达 ${textFiles.length} 个可能包含用户文案的文件；请检查新增/修改的文案是否已使用 i18n 框架，基准语言 ${defaultLang}，需支持 ${supported.join(', ')}。`
+      : `本轮触达 ${textFiles.length} 个可能包含用户文案的文件，但项目尚未配置 .openprd/i18n-config.json。如需启用多语言检查，可运行 openprd i18n-init . 或手动创建配置文件。`,
+    guideline: 'docs/basic/i18n-guidelines.md',
+  };
+}
+
 async function analyzeDevelopmentFile(projectRoot, targetPath, lineConfig) {
   const absolutePath = path.isAbsolute(targetPath)
     ? path.resolve(targetPath)
@@ -621,6 +656,7 @@ export async function checkDevelopmentStandardsWorkspace(projectRoot, options =
     files,
     wrapUp: buildDevCheckWrapUp(files, lineConfig),
     visualEvidence: await buildVisualEvidenceReminder(projectRoot, files),
+    i18nReminder: await buildI18nReminder(projectRoot, files),
     knowledgeReview,
     errors,
   };
@@ -658,3 +694,24 @@ export async function setDevCheckAutoRefactor(projectRoot, enabled) {
     },
   };
 }
+
+export async function initI18nConfig(projectRoot, options = {}) {
+  const configPath = cjoin(projectRoot, I18N_CONFIG_PATH);
+  const existing = await readJson(configPath).catch(() => null);
+  if (existing) {
+    return { created: false, configPath: normalizePathForReport(I18N_CONFIG_PATH), config: existing };
+  }
+  const defaultLang = options.defaultLanguage ?? 'zh-Hans';
+  const config = {
+    version: 1,
+    defaultLanguage: defaultLang,
+    supportedLanguages: [defaultLang, ...(defaultLang === 'en' ? ['zh-Hans'] : ['en'])],
+    enforceOnDevCheck: true,
+    platforms: [],
+    translationStrategy: 'key-value-file',
+    notes: '用户可随时修改此文件来调整默认语言、支持语种和检查策略',
+  };
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, 'utf8');
+  return { created: true, configPath: normalizePathForReport(I18N_CONFIG_PATH), config };
+}

package/src/fleet.js

@@ -1,9 +1,12 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import { cjoin, exists, writeJson } from './fs-utils.js';
+import { cjoin, exists } from './fs-utils.js';
+import { atomicWriteJson } from './kernel/index.js';
 import { hasLegacyOpenPrdArtifacts } from './openspec/migration.js';
 import { SOURCE_INVENTORY_IGNORE_DIRS } from './source-inventory.js';
 import { timestamp } from './time.js';
+import { createFleetTransactionContext, executeFleetProjectTransaction, planFleetProjectTransaction } from './upgrade/fleet-transaction.js';
+import { applySuccessfulFleetMutation, runStagedFleetMutation } from './upgrade/fleet-mutation.js';
 import { readWorkspaceRegistry, upsertWorkspaceRegistryEntry } from './workspace-registry.js';
 
 const FLEET_DEFAULT_MAX_DEPTH = 4;
@@ -35,6 +38,7 @@ const FLEET_PROJECT_MARKERS = [
 ];
 const FLEET_AGENT_MARKERS = ['.codex', '.claude', '.cursor', 'AGENTS.md', 'CLAUDE.md'];
 const FLEET_LEGACY_OPENPRD_MARKER = 'openprd-legacy-artifacts';
+const FLEET_TRANSACTIONAL_ACTIONS = new Set(['update', 'setup', 'backfill-work-units']);
 
 function normalizeCsvList(value) {
   if (!value) {
@@ -110,7 +114,7 @@ async function detectFleetMarkers(projectPath) {
   const entries = await fs.readdir(projectPath, { withFileTypes: true }).catch(() => []);
   const names = new Set(entries.map((entry) => entry.name));
   const markers = FLEET_PROJECT_MARKERS.filter((marker) => names.has(marker));
-  if (!markers.includes('.openprd') && await hasLegacyOpenPrdArtifacts(projectPath)) {
+  if (await hasLegacyOpenPrdArtifacts(projectPath)) {
     markers.push(FLEET_LEGACY_OPENPRD_MARKER);
   }
   return markers;
@@ -121,6 +125,10 @@ async function scanFleetProjects(rootPath, options = {}) {
   const maxDepth = parsePositiveInteger(options.maxDepth, FLEET_DEFAULT_MAX_DEPTH);
   const include = normalizeCsvList(options.include);
   const exclude = normalizeCsvList(options.exclude);
+  const infrastructureRoots = [options.openprdHome, options.backupRoot]
+    .filter(Boolean)
+    .map((candidate) => path.resolve(candidate))
+    .filter((candidate) => pathWithinRoot(root, candidate));
   const projects = [];
   const seenRealPaths = new Set();
 
@@ -128,6 +136,9 @@ async function scanFleetProjects(rootPath, options = {}) {
     if (depth > maxDepth) {
       return;
     }
+    if (currentPath !== root && infrastructureRoots.some((candidate) => pathWithinRoot(candidate, currentPath))) {
+      return;
+    }
 
     const name = path.basename(currentPath);
     if (depth > 0 && FLEET_IGNORE_DIRS.has(name)) {
@@ -141,6 +152,7 @@ async function scanFleetProjects(rootPath, options = {}) {
     seenRealPaths.add(realPath);
 
     const markers = await detectFleetMarkers(currentPath);
+    const containsLegacyArtifactTree = markers.includes(FLEET_LEGACY_OPENPRD_MARKER);
     if (markers.length > 0) {
       const category = classifyFleetMarkers(markers);
       const included = projectPathMatches(root, currentPath, include);
@@ -171,6 +183,11 @@ async function scanFleetProjects(rootPath, options = {}) {
       if (FLEET_IGNORE_DIRS.has(entry.name)) {
         continue;
       }
+      // A legacy `openprd/changes` tree belongs to the project just discovered
+      // above. It is migration input, never another fleet project root.
+      if (containsLegacyArtifactTree && entry.name === 'openprd') {
+        continue;
+      }
       await walk(cjoin(currentPath, entry.name), depth + 1);
     }
   }
@@ -298,32 +315,18 @@ function summarizeFleetProjects(projects) {
   return summary;
 }
 
-async function collectFleetProjectHealth(projectPath, options, doctorWorkspace) {
-  if (!doctorWorkspace) {
-    return { ok: true, errors: [] };
-  }
-  try {
-    // Batch refresh should focus on generated guidance and workspace skeleton health.
-    // Legacy content-doc debt remains available in direct doctor/standards checks.
-    const doctor = await doctorWorkspace(projectPath, {
-      tools: options.tools ?? 'all',
-      hookProfile: options.hookProfile,
-      enableUserCodexConfig: Boolean(options.enableUserCodexConfig),
-      codexHome: options.codexHome,
-      openprdHome: options.openprdHome,
-      docsContent: false,
-      sourceManuals: false,
-    });
-    return {
-      ok: doctor.ok,
-      errors: doctor.errors ?? [],
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      errors: [error instanceof Error ? error.message : String(error)],
-    };
-  }
+function attachFleetTransactionReport(item, plan, context) {
+  item.transaction = {
+    id: plan.transactionId,
+    reportVersion: plan.version,
+    strategy: context.applyStrategy,
+  };
+  item.version = { ...plan.versions };
+  item.checksum = { ...plan.checksum };
+  item.backup = { ...plan.backup };
+  item.migration = plan.migration;
+  item.rollback = { ...plan.rollback };
+  item.refusal = [...plan.refusal];
 }
 
 function buildFleetRegistrySummary(rootPath, options, registry) {
@@ -350,12 +353,7 @@ function buildFleetRegistrySummary(rootPath, options, registry) {
 }
 
 async function fleetWorkspaceImpl(rootPath, options = {}, dependencies = {}) {
-  const {
-    doctorWorkspace,
-    backfillWorkUnitsWorkspace,
-    setupAgentIntegrationWorkspace,
-    updateAgentIntegrationWorkspace,
-  } = dependencies;
+  const { doctorWorkspace, backfillWorkUnitsWorkspace } = dependencies;
   const root = path.resolve(rootPath);
   if (!(await exists(root))) {
     throw new Error(`Fleet root does not exist: ${root}`);
@@ -374,6 +372,11 @@ async function fleetWorkspaceImpl(rootPath, options = {}, dependencies = {}) {
   const scanned = await scanFleetProjects(root, options);
   const mergedProjects = await mergeFleetProjects(scanned, registryScope.projects);
   const projects = [];
+  const transactionContext = await createFleetTransactionContext({
+    openprdHome: options.openprdHome,
+    backupRoot: options.backupRoot,
+    targetVersion: options.targetVersion,
+  });
 
   for (const project of mergedProjects) {
     const plannedAction = plannedFleetAction(project.category, options);
@@ -393,6 +396,27 @@ async function fleetWorkspaceImpl(rootPath, options = {}, dependencies = {}) {
       continue;
     }
 
+    let transactionPlan = null;
+    if (FLEET_TRANSACTIONAL_ACTIONS.has(plannedAction)) {
+      try {
+        transactionPlan = await planFleetProjectTransaction({ ...project, plannedAction }, transactionContext, { dryRun });
+        attachFleetTransactionReport(item, transactionPlan, transactionContext);
+      } catch (error) {
+        item.status = 'failed';
+        item.ok = false;
+        item.errors = [error instanceof Error ? error.message : String(error)];
+        projects.push(item);
+        continue;
+      }
+      if (!transactionPlan.eligible) {
+        item.status = 'failed';
+        item.ok = false;
+        item.errors = transactionPlan.refusal.map((refusal) => refusal.message);
+        projects.push(item);
+        continue;
+      }
+    }
+
     if (dryRun) {
       if (plannedAction === 'backfill-work-units' && backfillWorkUnitsWorkspace) {
         const backfill = await backfillWorkUnitsWorkspace(project.path, { dryRun: true });
@@ -408,54 +432,49 @@ async function fleetWorkspaceImpl(rootPath, options = {}, dependencies = {}) {
       continue;
     }
 
+    if (transactionPlan) {
+      const transaction = await executeFleetProjectTransaction(transactionPlan, {
+        openprdHome: options.openprdHome,
+        beforeApply: dependencies.beforeFleetApply,
+        mutate: (stagingRoot, staging) => runStagedFleetMutation(
+          plannedAction,
+          stagingRoot,
+          options,
+          dependencies,
+          staging,
+        ),
+        afterApply: plannedAction === 'update' || plannedAction === 'setup'
+          ? async () => ({
+            registry: await upsertWorkspaceRegistryEntry(project.path, {
+              openprdHome: options.openprdHome,
+              action: plannedAction === 'update' ? 'fleet-update' : 'fleet-setup',
+            }),
+          })
+          : null,
+      });
+      attachFleetTransactionReport(item, transaction.plan, transactionContext);
+      if (!transaction.ok) {
+        item.status = 'failed';
+        item.ok = false;
+        item.errors = Array.from(new Set([
+          ...(transaction.mutationResult?.errors ?? []),
+          transaction.error instanceof Error ? transaction.error.message : String(transaction.error),
+        ].filter(Boolean)));
+        projects.push(item);
+        continue;
+      }
+      item.ok = true;
+      applySuccessfulFleetMutation(item, plannedAction, transaction);
+      item.errors = [
+        ...(transaction.mutationResult?.actionResult?.doctor?.errors ?? []),
+        ...(transaction.mutationResult?.backfill?.errors ?? []),
+      ];
+      projects.push(item);
+      continue;
+    }
+
     try {
-      if (plannedAction === 'update') {
-        const update = await updateAgentIntegrationWorkspace(project.path, {
-          tools: options.tools ?? 'all',
-          hookProfile: options.hookProfile,
-          force: Boolean(options.force),
-          enableUserCodexConfig: Boolean(options.enableUserCodexConfig),
-          codexHome: options.codexHome,
-          openprdHome: options.openprdHome,
-        });
-        const backfill = backfillWorkUnitsWorkspace
-          ? await backfillWorkUnitsWorkspace(project.path, {})
-          : { ok: true, changes: [], errors: [], totalVersions: 0, changedVersions: 0 };
-        const health = await collectFleetProjectHealth(project.path, options, doctorWorkspace);
-        item.status = update.ok && backfill.ok ? 'updated' : 'failed';
-        item.ok = update.ok && backfill.ok;
-        item.registry = update.registry ?? null;
-        item.changes = [
-          ...(update.migration?.changes ?? []).map((change) => ({ ...change, source: 'workspace' })),
-          ...(update.changes ?? []).map((change) => ({ ...change, source: 'agent' })),
-          ...(backfill.changes ?? []).map((change) => ({ ...change, source: 'work-unit' })),
-        ];
-        item.doctorOk = health.ok;
-        item.healthOk = health.ok;
-        item.healthErrors = health.errors;
-        item.workUnits = {
-          totalVersions: backfill.totalVersions,
-          changedVersions: backfill.changedVersions,
-        };
-        item.errors = [...(update.doctor?.errors ?? []), ...(backfill.errors ?? [])];
-      } else if (plannedAction === 'setup') {
-        const setup = await setupAgentIntegrationWorkspace(project.path, {
-          tools: options.tools ?? 'all',
-          hookProfile: options.hookProfile,
-          force: Boolean(options.force),
-          enableUserCodexConfig: Boolean(options.enableUserCodexConfig),
-          codexHome: options.codexHome,
-          openprdHome: options.openprdHome,
-        });
-        item.status = setup.ok ? 'setup' : 'failed';
-        item.ok = setup.ok;
-        item.registry = setup.registry ?? null;
-        item.changes = [
-          ...(setup.migration?.changes ?? []).map((change) => ({ ...change, source: 'workspace' })),
-          ...(setup.changes ?? []).map((change) => ({ ...change, source: 'agent' })),
-        ];
-        item.errors = setup.doctor?.errors ?? [];
-      } else if (plannedAction === 'doctor') {
+      if (plannedAction === 'doctor') {
         const doctor = await doctorWorkspace(project.path, {
           tools: options.tools ?? 'all',
           hookProfile: options.hookProfile,
@@ -467,19 +486,6 @@ async function fleetWorkspaceImpl(rootPath, options = {}, dependencies = {}) {
         item.ok = doctor.ok;
         item.doctorOk = doctor.ok;
         item.errors = doctor.errors ?? [];
-      } else if (plannedAction === 'backfill-work-units') {
-        if (!backfillWorkUnitsWorkspace) {
-          throw new Error('Missing fleet dependency: backfillWorkUnitsWorkspace');
-        }
-        const backfill = await backfillWorkUnitsWorkspace(project.path, {});
-        item.status = backfill.ok ? (backfill.totalVersions > 0 ? 'backfilled' : 'skipped') : 'failed';
-        item.ok = backfill.ok;
-        item.workUnits = {
-          totalVersions: backfill.totalVersions,
-          changedVersions: backfill.changedVersions,
-        };
-        item.changes = (backfill.changes ?? []).map((change) => ({ ...change, source: 'work-unit' }));
-        item.errors = backfill.errors ?? [];
       } else if (plannedAction === 'sync-registry') {
         const registrySync = await upsertWorkspaceRegistryEntry(project.path, {
           openprdHome: options.openprdHome,
@@ -515,6 +521,17 @@ async function fleetWorkspaceImpl(rootPath, options = {}, dependencies = {}) {
       backfillWorkUnits: Boolean(options.backfillWorkUnits),
       syncRegistry: Boolean(options.syncRegistry),
     },
+    upgrade: {
+      reportVersion: transactionContext.version,
+      transactionId: transactionContext.transactionId,
+      targetVersion: transactionContext.targetVersion,
+      checksumAlgorithm: transactionContext.checksumAlgorithm,
+      applyStrategy: transactionContext.applyStrategy,
+      backupRoot: transactionContext.backupRoot,
+      archivePolicy: 'refuse-write',
+      symlinkPolicy: 'refuse-write',
+      compatibilityPolicy: 'refuse-too-new',
+    },
     scannedAt: timestamp(),
     summary: summarizeFleetProjects(projects),
     registry: registrySummary,
@@ -525,8 +542,8 @@ async function fleetWorkspaceImpl(rootPath, options = {}, dependencies = {}) {
 
   if (options.report) {
     const reportPath = path.resolve(options.report);
-    await writeJson(reportPath, result);
     result.reportPath = reportPath;
+    await atomicWriteJson(reportPath, result);
   }
 
   return result;

package/src/gates/index.js

@@ -0,0 +1,2 @@
+export * from './scoped-gates.js';
+export * from './store.js';