@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/commands/typecheck.js

@@ -1,209 +1,60 @@
 // SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge typecheck`: whole-project TypeScript type checking driven by
- * user-supplied jsconfig.json paths.
- *
- * Distinct from `patchLint.checkJs`: that pass is patch-hygiene (scoped to
- * patch-owned `.sys.mjs`, run automatically by `fireforge lint`). This
- * command is CI-grade: it runs whole projects with the user's own compiler
- * options. The two share their Firefox-globals shim and the same
- * suppressed-diagnostic set so a file that lints clean cannot fail typecheck
- * for a reason the operator could not have inferred from the docs.
- *
- * Exits non-zero on any error-severity diagnostic. Warnings print but do not
- * fail.
- */
-import { Command } from 'commander';
-import { getProjectPaths, loadConfig } from '../core/config.js';
-import { furnaceConfigExists, loadFurnaceConfig } from '../core/furnace-config.js';
-import { findJsconfigPathsDrift, syncFurnaceJsconfigPaths } from '../core/furnace-jsconfig.js';
-import { withPrivateGitIndex } from '../core/git-readonly-index.js';
-import { buildPatchQueueContext } from '../core/patch-lint.js';
-import { relativeForDisplay, runTypecheck } from '../core/typecheck.js';
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { pathExists } from '../utils/fs.js';
-import { info, intro, outro, success, warn } from '../utils/logger.js';
-import { buildPerRunCheckJs } from './lint-per-run-checkjs.js';
-/**
- * Resolves the project list to type-check. `--project` wins over
- * config. If neither is set, throws a clear error pointing at both
- * paths to a fix (add the config field or pass --project).
- */
-export function resolveTypecheckProjects(configTypecheck, override) {
-    if (override !== undefined) {
-        if (override.trim() === '') {
-            throw new InvalidArgumentError('--project requires a non-empty path', '--project');
-        }
-        return {
-            projects: [override],
-            ...(configTypecheck?.extraShim !== undefined ? { extraShim: configTypecheck.extraShim } : {}),
-            // Preserve any per-project override for the targeted path so a one-off
-            // `--project` run honours its opt-out / shim override just like a full run.
-            ...(configTypecheck?.projectOverrides !== undefined
-                ? { projectOverrides: configTypecheck.projectOverrides }
-                : {}),
-        };
-    }
-    if (!configTypecheck) {
-        throw new GeneralError('No typecheck configuration found. Add a "typecheck": { "projects": [...] } block to ' +
-            'fireforge.json, or pass --project <path> for a one-off run.');
-    }
-    return configTypecheck;
-}
-/**
- * Formats a single issue for CLI display. `[<project>] <file>:<line>:<col> TS<code> <message>`
- * matches the format `tsc -p` produces with `--pretty false`, so output
- * piped into editor jump-lists works without per-tool tweaks.
- */
-function formatIssue(projectRoot, issue) {
-    const file = relativeForDisplay(projectRoot, issue.file);
-    const codeLabel = issue.code > 0 ? ` TS${issue.code}` : '';
-    return `[${issue.project}] ${file}:${issue.line}:${issue.column}${codeLabel} ${issue.message}`;
-}
-/**
- * Top-level entry point invoked by the registered Commander action.
- * Loads config, resolves projects, runs typecheck, prints the result,
- * and throws `GeneralError` to set a non-zero exit on errors.
- */
-export async function typecheckCommand(projectRoot, options) {
-    intro('FireForge typecheck');
-    // Read-only to the operator, an index WRITER to git without this scope:
-    // the Furnace jsconfig reconciler and the project resolution
-    // below touch `engine/`, and any git plumbing they reach would refresh
-    // the primary checkout's index under a concurrent `fireforge test`.
-    return withPrivateGitIndex(getProjectPaths(projectRoot).engine, () => runTypecheckCommandBody(projectRoot, options));
-}
-async function runTypecheckCommandBody(projectRoot, options) {
-    // Validate project is initialised. `loadConfig` throws on missing
-    // fireforge.json, and withErrorHandling at the CLI layer renders the
-    // resulting `ConfigNotFoundError` cleanly, so we don't need to
-    // re-wrap.
-    getProjectPaths(projectRoot);
-    const config = await loadConfig(projectRoot);
-    const cfg = resolveTypecheckProjects(config.typecheck, options.project);
-    // Regenerate a stale Furnace-managed jsconfig before running: the generated
-    // `compilerOptions.paths` shim drifts when components are added or renamed
-    // without a re-deploy, and a stale shim reports type errors in files the
-    // session never touched. Run the same reconciler `furnace deploy`/`sync`
-    // use so typecheck checks against the current workspace.
-    await regenerateStaleGeneratedJsconfig(projectRoot);
-    info(`Running typecheck across ${cfg.projects.length} project(s): ${cfg.projects.join(', ')}`);
-    const results = await runTypecheck(projectRoot, cfg, {
-        ...(options.noCache === true ? { noCache: true } : {}),
-    });
-    // Fold the EXPORT-TIME authority into this pass. Per-patch lint runs
-    // checkJs over the queue's patch-owned modules in relative isolation and
-    // resolves imported typedefs differently from the whole-project pass, so
-    // `typecheck` can report 0 errors across every project while the very next
-    // `export` fails per-patch lint with `checkjs-type-error` findings. Two
-    // authorities that disagree, with the stricter one speaking only at export
-    // time, is not a usable CI gate: running both here makes `typecheck` green
-    // MEAN export-clean types.
-    const patchIssues = await collectPatchLintCheckJsIssues(projectRoot);
-    reportResults(projectRoot, results, patchIssues);
-}
-/**
- * Runs the per-patch-lint checkJs pass (the same program `export` and
- * `lint --per-patch` use) and returns its findings.
- *
- * Returns an empty list when `patchLint.checkJs` is off or the project has
- * no patch queue: there is no second authority to reconcile then.
- */
-async function collectPatchLintCheckJsIssues(projectRoot) {
-    const paths = getProjectPaths(projectRoot);
-    const config = await loadConfig(projectRoot);
-    if (config.patchLint?.checkJs !== true)
-        return [];
-    if (!(await pathExists(paths.patches)))
-        return [];
-    const ctx = await buildPatchQueueContext(paths.patches, config);
-    const checkJs = buildPerRunCheckJs(projectRoot, paths, config, ctx);
-    if (checkJs === undefined)
-        return [];
-    info('Also running the per-patch checkJs pass (the authority `export` enforces).');
-    const grouped = await checkJs.getGrouped();
-    return [...grouped.global, ...[...grouped.byFile.values()].flat()];
-}
-/**
- * Staleness-checks and regenerates the Furnace-managed jsconfig
- * (`furnace.json` → `typecheckJsconfig`) before typecheck runs. No-op when
- * the project has no furnace.json or no `typecheckJsconfig` is configured.
- * A missing `typecheckJsconfig` file surfaces the reconciler's own clear
- * error rather than producing phantom type diagnostics.
- */
-async function regenerateStaleGeneratedJsconfig(projectRoot) {
-    if (!(await furnaceConfigExists(projectRoot)))
-        return;
-    const furnaceConfig = await loadFurnaceConfig(projectRoot);
-    if (!furnaceConfig.typecheckJsconfig)
-        return;
-    const drift = await findJsconfigPathsDrift(projectRoot, furnaceConfig);
-    if (!drift.changed)
-        return;
-    info(`Regenerating stale generated jsconfig ${furnaceConfig.typecheckJsconfig} before typecheck ` +
-        `(+${drift.added.length} added, ~${drift.updated.length} updated, ` +
-        `-${drift.pruned.length} pruned).`);
-    await syncFurnaceJsconfigPaths(projectRoot, furnaceConfig);
-}
-/**
- * Prints all issues, computes the per-project + total counts, and
- * throws on errors. Extracted so it can be exercised directly by
- * the CLI test without spawning a child process.
- */
-export function reportResults(projectRoot, results, patchLintIssues = []) {
-    let totalErrors = 0;
-    let totalWarnings = 0;
-    // Per-patch checkJs findings are reported in the SAME tally: a split
-    // report would let an operator read "0 errors" off the project summary
-    // and still be refused at export.
-    for (const issue of patchLintIssues) {
-        if (issue.severity === 'error')
-            totalErrors += 1;
-        else
-            totalWarnings += 1;
-        warn(`[per-patch ${issue.check}] ${issue.file}: ${issue.message}`);
-    }
-    for (const result of results) {
-        const errors = result.issues.filter((i) => i.category === 'error');
-        const warnings = result.issues.filter((i) => i.category === 'warning');
-        totalErrors += errors.length;
-        totalWarnings += warnings.length;
-        for (const issue of warnings)
-            warn(formatIssue(projectRoot, issue));
-        for (const issue of errors)
-            warn(formatIssue(projectRoot, issue));
-    }
-    const summary = `Typecheck: ${totalErrors} error(s), ${totalWarnings} warning(s) across ` +
-        `${results.length} project(s)` +
-        (patchLintIssues.length > 0
-            ? ` (including ${patchLintIssues.length} per-patch checkJs finding(s))`
-            : '');
-    if (totalErrors === 0) {
-        success(summary);
-        outro(totalWarnings > 0 ? 'Typecheck passed with warnings' : 'Typecheck passed');
-        return;
-    }
-    info(summary);
-    outro('Typecheck failed');
-    throw new GeneralError(`Typecheck found ${totalErrors} error(s) across ${results.length} project(s).`);
-}
-/**
- * Registers the `typecheck` command on the CLI program.
- */
-export function registerTypecheck(program, { getProjectRoot, withErrorHandling }) {
-    program
-        .command('typecheck')
-        .description('Run TypeScript type checking against project-owned jsconfig.json files (CI-grade, whole-project)')
-        .option('--project <path>', 'Override typecheck.projects with a single jsconfig.json path (one-off run)')
-        .option('--no-cache', 'Check every project from scratch; neither read nor write the incremental build info in .fireforge/typecheck/')
-        .action(withErrorHandling(async (options) => {
-        const opts = {};
-        if (options.project !== undefined) {
-            opts.project = options.project;
-        }
-        if (options.cache === false) {
-            opts.noCache = true;
-        }
-        await typecheckCommand(getProjectRoot(), opts);
-    }));
-}
+import { defineCommand, lockWaitMs, opt } from '../cli/command.js';
+import { FireForgeError } from '../kernel/errors.js';
+import { deployComponents, lintSubject, requireCurrentTyping, typeCacheDir, withWorkspace, } from '../mode/index.js';
+import { loadProject } from '../project/index.js';
+import { explainTypecheck, explanationJson, renderExplanation, renderTypecheckReport, runTypecheck, typecheckReportJson, typecheckVerdict, } from '../typecheck/index.js';
+import { workspaceOptions } from './workspace.js';
+export const typecheck = defineCommand({
+    name: 'typecheck',
+    summary: 'Type-check the configured projects and the owned files',
+    description: 'Checks each typecheck.projects jsconfig whole, with the Firefox-globals shim, and the ' +
+        "owned files with lint's strict checkJs pass. Any error fails the run. The typing files " +
+        'Furnace generates must be current ("fireforge furnace types").',
+    group: 'Daily',
+    options: {
+        project: opt.list('Check this project instead of typecheck.projects; repeat for several', {
+            valueName: 'path',
+        }),
+        explain: opt.string('Check nothing; print how both passes see this file', {
+            valueName: 'file',
+        }),
+        ...workspaceOptions,
+    },
+    json: true,
+    run: async (ctx, _args, { project: projects, explain, workspace, waitLock }) => {
+        const project = await loadProject(ctx.cwd, ctx.env);
+        await requireCurrentTyping(project);
+        const waitMs = lockWaitMs(waitLock);
+        await withWorkspace(project, { command: 'typecheck', workspace, waitMs }, async (leased) => {
+            await deployComponents(leased, { waitMs });
+            const subject = await lintSubject(project, { workspace: leased });
+            const request = {
+                config: project.config,
+                projectRoot: project.root,
+                engineDir: leased.engineDir,
+                changes: subject.changes,
+                engine: subject.engine,
+                cacheDir: typeCacheDir(project),
+                ...(projects.length === 0 ? {} : { projects }),
+            };
+            if (explain !== undefined) {
+                const explanation = await explainTypecheck(request, explain);
+                for (const line of renderExplanation(explanation))
+                    ctx.out.line(line);
+                ctx.out.json(explanationJson(explanation));
+                return;
+            }
+            const report = await runTypecheck(request);
+            for (const line of renderTypecheckReport(report))
+                ctx.out.line(line);
+            ctx.out.json(typecheckReportJson(report));
+            const verdict = typecheckVerdict(report);
+            if (!verdict.pass) {
+                throw new FireForgeError('typecheck-failed', `Typecheck found ${verdict.errors} error(s).`, {
+                    hint: 'Fix the errors listed above; "fireforge typecheck --explain <file>" shows how both passes see a file.',
+                });
+            }
+        });
+    },
+});

package/dist/src/commands/verify.js

@@ -1,335 +1,29 @@
 // SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge verify`: read-only fsck for the patch queue.
- *
- * Combines the manifest consistency check (orphan files, missing entries,
- * files-affected mismatch, duplicate entries) with the cross-patch lint
- * rules (duplicate /dev/null creation, forward imports). Does not run
- * `planExport` per patch. That is out of scope because it
- * would couple verify to engine state and make the command too slow to be
- * useful as a pre-flight gate. Engine-level patch application issues are
- * still covered by the existing `fireforge doctor` and `fireforge import`
- * paths.
- *
- * Exits non-zero when any error-severity finding is reported so CI can
- * treat the output as pass/fail.
- */
-import { join } from 'node:path';
-import { Command } from 'commander';
-import { getProjectPaths, loadConfig } from '../core/config.js';
-import { collectFurnaceManagedPrefixes } from '../core/furnace-config.js';
-import { isGitRepository } from '../core/git.js';
-import { withPrivateGitIndex } from '../core/git-readonly-index.js';
-import { expandUntrackedDirectoryEntries, getWorkingTreeStatus } from '../core/git-status.js';
-import { collectWorktreeModuleFiles, findUnresolvedSystemModuleImports, formatUnresolvedSystemModuleImports, } from '../core/module-resolution-preflight.js';
-import { buildPatchQueueContext, formatPatchLintIssue, lintPatchQueue, } from '../core/patch-lint.js';
-import { loadPatchesManifest, validatePatchesManifestConsistency } from '../core/patch-manifest.js';
-import { evaluatePatchPolicy } from '../core/patch-policy.js';
-import { evaluatePatchPolicyContentForQueue } from '../core/patch-policy-content.js';
-import { collectPatchRegistrationReferences } from '../core/patch-registration-refs.js';
-import { buildPatchClaims } from '../core/status-classify.js';
-import { classifyFiles } from '../core/status-classify.js';
-import { GeneralError } from '../errors/base.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { info, intro, outro, success, warn } from '../utils/logger.js';
-import { anyPatchInScope, isFilenameInScope, resolveVerifyScope, scopeLintIssues, scopePatches, } from './verify-scope.js';
-/**
- * Walks each patch body in the manifest, extracts the set of
- * component-shaped registration references it adds (widget paths
- * implied by jar.mn + customElements.js, and FTL paths implied by locale
- * jar.mn), and confirms every reference is either created by some
- * patch in the queue or present as a tracked file in engine/. Any
- * unreachable reference is a dangling-registration error: the patch
- * registers a file that nothing in the world supplies, which fails at
- * install time.
- */
-async function detectDanglingRegistrations(patchesDir, engineDir, patches, scope) {
-    // Aggregate the set of all paths any patch in the queue is responsible for
-    // (per `filesAffected`). Individual patch bodies are deliberately not
-    // parsed for new-file creations here: `filesAffected` is already the
-    // contract manifest callers rely on, and
-    // `validatePatchesManifestConsistency` has already ensured the two are in
-    // sync. Using that list keeps this validator fast.
-    const coveredByPatches = new Set();
-    for (const patch of patches) {
-        for (const file of patch.filesAffected) {
-            coveredByPatches.add(file);
-        }
-    }
-    // Every patch supplies targets; only the scoped ones are judged.
-    const issues = [];
-    for (const patch of scopePatches(patches, scope)) {
-        const patchPath = join(patchesDir, patch.filename);
-        if (!(await pathExists(patchPath)))
-            continue;
-        let body;
-        try {
-            body = await readText(patchPath);
-        }
-        catch {
-            // Bad file read is surfaced by the manifest consistency check
-            // already. Skipping here avoids double-reporting the same issue.
-            continue;
-        }
-        const refs = collectPatchRegistrationReferences(body);
-        if (refs.length === 0)
-            continue;
-        for (const ref of refs) {
-            if (coveredByPatches.has(ref.targetPath))
-                continue;
-            // Engine existence check: if the target file is already present in
-            // engine/ (upstream Firefox ships it, or a separate baseline branch
-            // has it), the registration is not dangling. "Is this tracked by git"
-            // cannot be probed without a git round-trip. Existence on disk is a
-            // close-enough proxy for verify's read-only context.
-            if (await pathExists(join(engineDir, ref.targetPath)))
-                continue;
-            issues.push({
-                patchFilename: patch.filename,
-                targetPath: ref.targetPath,
-                source: ref.source,
-            });
-        }
-    }
-    return issues;
-}
-function detectCrossPatchFileClaims(manifestPatches) {
-    const claims = buildPatchClaims(manifestPatches);
-    const results = [];
-    for (const [path, filenames] of claims) {
-        if (filenames.length > 1) {
-            results.push({ path, filenames });
-        }
-    }
-    return results;
-}
-async function detectWorktreeOwnershipDrift(projectRoot, engineDir, patchesDir, binaryName, scope) {
-    if (!(await pathExists(engineDir)) || !(await isGitRepository(engineDir))) {
-        return { unowned: [], patchOwnedDrift: [] };
-    }
-    const entries = await expandUntrackedDirectoryEntries(engineDir, await getWorkingTreeStatus(engineDir));
-    const furnacePrefixes = await collectFurnaceManagedPrefixes(projectRoot);
-    const classified = await classifyFiles(entries, engineDir, patchesDir, binaryName, furnacePrefixes);
-    return {
-        // An unowned change belongs to no patch, so no --patches scope covers it.
-        unowned: [
-            ...new Set(classified
-                .filter((entry) => scope === undefined && entry.classification === 'unmanaged')
-                .map((entry) => entry.file)),
-        ].sort(),
-        patchOwnedDrift: [
-            ...new Set(classified
-                .filter((entry) => entry.classification === 'patch-owned-drift' &&
-                anyPatchInScope(scope, entry.owner === undefined ? [] : [entry.owner]))
-                .map((entry) => entry.file)),
-        ].sort(),
-    };
-}
-/** The warning groups for unowned changes and patch-owned drift. */
-function buildWorktreeDriftGroups(drift) {
-    const groups = [];
-    if (drift.unowned.length > 0) {
-        groups.push({
-            title: `Unowned worktree changes (${drift.unowned.length})`,
-            issues: drift.unowned.map((file) => `${file} is changed in engine/ but is not listed in any patch filesAffected entry`),
-            errorCount: 0,
-            warningCount: drift.unowned.length,
-        });
-    }
-    if (drift.patchOwnedDrift.length > 0) {
-        groups.push({
-            title: `Patch-owned worktree drift (${drift.patchOwnedDrift.length})`,
-            issues: drift.patchOwnedDrift.map((file) => `${file} is claimed by exactly one patch, but engine/ no longer matches that patch output`),
-            errorCount: 0,
-            warningCount: drift.patchOwnedDrift.length,
-        });
-    }
-    return groups;
-}
-/**
- * Collects the same queue-health findings reported by `fireforge verify`
- * without printing. Used by doctor recovery paths that need a read-only
- * "is this queue healthy?" decision before clearing stale state.
- *
- * @param projectRoot - Project root directory
- * @param scope - `verify --patches`: keep only the findings that name these
- *   patches (see verify-scope.ts). Omitted, every finding counts.
- */
-export async function collectPatchQueueHealth(projectRoot, scope) {
-    const paths = getProjectPaths(projectRoot);
-    const config = await loadConfig(projectRoot);
-    if (!(await pathExists(paths.patches))) {
-        return {
-            hasPatchesDirectory: false,
-            groups: [],
-            errorCount: 0,
-            warningCount: 0,
-        };
-    }
-    const groups = [];
-    let errorCount = 0;
-    let warningCount = 0;
-    const consistencyIssues = (await validatePatchesManifestConsistency(paths.patches)).filter((issue) => isFilenameInScope(scope, issue.filename));
-    if (consistencyIssues.length > 0) {
-        const issues = consistencyIssues.map((issue) => `[${issue.code}] ${issue.message}`);
-        groups.push({
-            title: `Manifest consistency issues (${consistencyIssues.length})`,
-            issues,
-            errorCount: consistencyIssues.length,
-            warningCount: 0,
-        });
-        errorCount += consistencyIssues.length;
-    }
-    const manifest = await loadPatchesManifest(paths.patches);
-    if (manifest) {
-        const policyIssues = [
-            ...evaluatePatchPolicy(config, manifest),
-            ...(await evaluatePatchPolicyContentForQueue(config, projectRoot, paths.patches, manifest)),
-        ].filter((issue) => isFilenameInScope(scope, issue.filename));
-        if (policyIssues.length > 0) {
-            const policyErrors = policyIssues.filter((issue) => issue.severity === 'error').length;
-            const policyWarnings = policyIssues.length - policyErrors;
-            groups.push({
-                title: `Patch policy issues (${policyIssues.length})`,
-                issues: policyIssues.map((issue) => {
-                    const label = issue.severity === 'error' ? 'ERROR' : 'WARN';
-                    return `${label} [${issue.code}] ${issue.filename}: ${issue.message}`;
-                }),
-                errorCount: policyErrors,
-                warningCount: policyWarnings,
-            });
-            errorCount += policyErrors;
-            warningCount += policyWarnings;
-        }
-        // Engine-aware module-resolution preflight. The queue-level
-        // `unregistered-system-module` rule only sees modules a patch NEWLY
-        // CREATES. This asks the same question of the engine, so an import ADDED
-        // to an existing module is named as text instead of surfacing later as a
-        // bare `xpcshell return code: -11` with zero output.
-        // Unscoped, the engine worktree joins in: an unexported chrome script
-        // importing an unexported, unregistered module crashes every objdir
-        // start before either file is in the queue. A scoped run never judges
-        // unmanaged files.
-        if (await pathExists(paths.engine)) {
-            const worktree = scope === undefined && (await isGitRepository(paths.engine))
-                ? await collectWorktreeModuleFiles(paths.engine)
-                : undefined;
-            const unresolved = await findUnresolvedSystemModuleImports(paths.engine, scopePatches(manifest.patches, scope).flatMap((patch) => patch.filesAffected), worktree);
-            if (unresolved.length > 0) {
-                groups.push({
-                    title: `Unresolvable system-module imports (${unresolved.length})`,
-                    issues: formatUnresolvedSystemModuleImports(unresolved),
-                    errorCount: unresolved.length,
-                    warningCount: 0,
-                });
-                errorCount += unresolved.length;
-            }
-        }
-        const crossClaims = detectCrossPatchFileClaims(manifest.patches).filter((claim) => anyPatchInScope(scope, claim.filenames));
-        if (crossClaims.length > 0) {
-            groups.push({
-                title: `Cross-patch filesAffected conflicts (${crossClaims.length})`,
-                issues: crossClaims.map((claim) => `${claim.path}  claimed by: ${claim.filenames.join(', ')}`),
-                errorCount: crossClaims.length,
-                warningCount: 0,
-            });
-            errorCount += crossClaims.length;
-        }
-    }
-    const ctx = await buildPatchQueueContext(paths.patches);
-    const lintIssues = scopeLintIssues(lintPatchQueue(ctx), scope);
-    if (lintIssues.length > 0) {
-        const lintErrors = lintIssues.filter((issue) => issue.severity === 'error').length;
-        const lintWarnings = lintIssues.filter((issue) => issue.severity === 'warning').length;
-        groups.push({
-            title: `Cross-patch lint issues (${lintIssues.length})`,
-            issues: lintIssues.map((issue) => {
-                const label = issue.severity === 'error' ? 'ERROR' : issue.severity === 'warning' ? 'WARN' : 'NOTICE';
-                return `${label} ${formatPatchLintIssue(issue)}`;
-            }),
-            errorCount: lintErrors,
-            warningCount: lintWarnings,
-        });
-        errorCount += lintErrors;
-        warningCount += lintWarnings;
-    }
-    if (manifest) {
-        const worktreeDrift = await detectWorktreeOwnershipDrift(projectRoot, paths.engine, paths.patches, config.binaryName, scope);
-        const driftGroups = buildWorktreeDriftGroups(worktreeDrift);
-        groups.push(...driftGroups);
-        warningCount += driftGroups.reduce((sum, group) => sum + group.warningCount, 0);
-        const registrationIssues = await detectDanglingRegistrations(paths.patches, paths.engine, manifest.patches, scope);
-        if (registrationIssues.length > 0) {
-            groups.push({
-                title: `Dangling registration references (${registrationIssues.length})`,
-                issues: registrationIssues.map((issue) => `${issue.patchFilename}: registers ${issue.targetPath} via ${issue.source}, but no patch body or engine file supplies it`),
-                errorCount: registrationIssues.length,
-                warningCount: 0,
-            });
-            errorCount += registrationIssues.length;
-        }
-    }
-    return {
-        hasPatchesDirectory: true,
-        groups,
-        errorCount,
-        warningCount,
-    };
-}
-/**
- * Runs the `verify` command: manifest consistency + cross-patch lint.
- * Read-only. Exits non-zero on any error-severity finding.
- *
- * @param projectRoot - Project root directory
- * @param options - `patches`: the raw `--patches` values
- */
-export async function verifyCommand(projectRoot, options = {}) {
-    intro('FireForge Verify');
-    const scope = await resolveVerifyScope(getProjectPaths(projectRoot).patches, options.patches);
-    if (scope !== undefined) {
-        info(`Judging only: ${[...scope.patches].join(', ')}`);
-    }
-    // `verify` is read-only to the OPERATOR but not to git: the working-tree
-    // status probe refreshes (and rewrites) `engine/.git/index`, making this
-    // command a second writer of the primary checkout and invalidating a
-    // concurrent `fireforge test`'s engine fingerprint. A private index keeps
-    // every refresh off the primary checkout.
-    const health = await withPrivateGitIndex(getProjectPaths(projectRoot).engine, () => collectPatchQueueHealth(projectRoot, scope));
-    if (!health.hasPatchesDirectory) {
-        info('No patches directory. Nothing to verify.');
-        outro('Verify clean');
-        return;
-    }
-    for (const group of health.groups) {
-        warn(`${group.title}:`);
-        for (const issue of group.issues) {
-            warn(`  ${issue}`);
-        }
-    }
-    if (health.errorCount === 0 && health.warningCount === 0) {
-        success('Patch queue is consistent.');
-        outro('Verify clean');
-        return;
-    }
-    info(`\nVerify: ${health.errorCount} error(s), ${health.warningCount} warning(s)`);
-    if (health.errorCount > 0) {
-        outro('Verify failed');
-        throw new GeneralError(`fireforge verify found ${health.errorCount} error(s). Fix these before running export/import/rebase. Use "patch staged-dependency" for intentional staged imports, or preview "patch move-files" / "patch reorder --dry-run" / "re-export --files --dry-run" for ownership repairs.`);
-    }
-    outro('Verify passed with warnings');
-}
-/**
- * Registers the `verify` command on the CLI program.
- *
- * @param program - Commander root program
- * @param context - Shared CLI registration context
- */
-export function registerVerify(program, { getProjectRoot, withErrorHandling }) {
-    program
-        .command('verify')
-        .description('Read-only fsck for the patch queue (manifest + cross-patch lint)')
-        .option('--patches <names...>', 'Judge only findings that name these patches (filename, stem, order number, manifest name, or slug; repeat, or separate with commas or whitespace). Queue-wide findings stay; unowned worktree changes drop out')
-        .action(withErrorHandling(async (options) => {
-        await verifyCommand(getProjectRoot(), options);
-    }));
-}
+import { defineCommand, lockOptions, lockWaitMs } from '../cli/command.js';
+import { verify as verifyStorage, verifyOutcome, withOwnedRead } from '../mode/index.js';
+import { loadProject } from '../project/index.js';
+export const verify = defineCommand({
+    name: 'verify',
+    summary: 'Check the integrity of where the owned changes are stored',
+    description: 'Patch mode: the manifest, every patch body, and that the queue replays onto the engine. ' +
+        'Source mode: every override record and owned file against the pristine repository.',
+    group: 'Daily',
+    options: { ...lockOptions },
+    json: true,
+    run: async (ctx, _args, opts) => {
+        const project = await loadProject(ctx.cwd, ctx.env);
+        const report = await withOwnedRead(project, { command: 'verify', waitMs: lockWaitMs(opts.waitLock) }, () => verifyStorage(project));
+        for (const problem of report.problems) {
+            const subject = problem.subject === undefined ? '' : `${problem.subject}: `;
+            ctx.out.line(`${problem.code}  ${subject}${problem.message}`);
+            if (problem.hint !== undefined)
+                ctx.out.line(`  ${problem.hint}`);
+        }
+        const outcome = verifyOutcome(report);
+        if ('sound' in outcome)
+            ctx.out.line(outcome.sound);
+        ctx.out.json({ ...report, pass: report.problems.length === 0 });
+        if ('failure' in outcome)
+            throw outcome.failure;
+    },
+});

package/dist/src/commands/version.js

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { defineCommand } from '../cli/command.js';
+import { cliVersion, packageVersion } from '../cli/version.js';
+export const version = defineCommand({
+    name: 'version',
+    summary: 'Print the FireForge version and build identity',
+    group: 'Diagnostics',
+    json: true,
+    run: async (ctx) => {
+        const build = await cliVersion();
+        ctx.out.line(build);
+        ctx.out.json({ version: await packageVersion(), build, node: process.version });
+    },
+});