@hominis/fireforge 0.10.1 → 0.11.1

package/dist/src/core/lint-projection.js

@@ -0,0 +1,44 @@
+/**
+ * Diffs projected lint issues against the baseline and returns those
+ * considered "new" regressions.
+ *
+ * The equality key is the issue fingerprint when present, otherwise the
+ * full `(check, file, message)` triple. Fingerprints are emitted by rules
+ * whose message text can drift between otherwise-equivalent runs (for
+ * example because the message embeds later-owner filenames or positional
+ * detail). Falling back to the full tuple keeps the helper conservative
+ * for older/non-fingerprinted rules: if their message changes, we would
+ * rather surface a potential regression than silently swallow it.
+ *
+ * Consumption order within the projected list is stable (the input
+ * order is preserved), so when baseline has N issues for a key and
+ * projected has N+M for the same key, the *last* M projected issues on
+ * that key are reported as regressions. That keeps the reporting
+ * deterministic and gives the operator at least one concrete message
+ * per regression even when only counts differ.
+ *
+ * @param baseline - Error-severity issues from the current queue
+ * @param projected - Error-severity issues from the projected queue
+ * @returns Subset of `projected` not matched by a baseline counterpart
+ */
+export function computeProjectedLintRegressions(baseline, projected) {
+    const issueKey = (i) => i.fingerprint ?? `${i.check}|${i.file}|${i.message}`;
+    const baselineCounts = new Map();
+    for (const issue of baseline) {
+        const key = issueKey(issue);
+        baselineCounts.set(key, (baselineCounts.get(key) ?? 0) + 1);
+    }
+    const regressions = [];
+    const consumedByKey = new Map();
+    for (const issue of projected) {
+        const key = issueKey(issue);
+        const allowed = baselineCounts.get(key) ?? 0;
+        const consumed = consumedByKey.get(key) ?? 0;
+        if (consumed >= allowed) {
+            regressions.push(issue);
+        }
+        consumedByKey.set(key, consumed + 1);
+    }
+    return regressions;
+}
+//# sourceMappingURL=lint-projection.js.map

package/dist/src/core/mach.d.ts

@@ -33,8 +33,10 @@ export interface MachCommandResult {
  */
 export declare function runMach(args: string[], engineDir: string, options?: MachOptions): Promise<number>;
 /**
- * Runs a mach command while streaming output to the terminal and capturing it
- * for post-run diagnostics.
+ * Runs a mach command while streaming output to the terminal and capturing
+ * the tail of stdout/stderr for post-run diagnostics. Output beyond
+ * {@link CAPTURE_TAIL_LIMIT} is discarded from the head to prevent unbounded
+ * memory growth during long-lived processes like Storybook.
  */
 export declare function runMachCapture(args: string[], engineDir: string, options?: Omit<MachOptions, 'inherit'>): Promise<MachCommandResult>;
 /**

package/dist/src/core/mach.js

@@ -41,8 +41,17 @@ export async function runMach(args, engineDir, options = {}) {
     return result.exitCode;
 }
 /**
- * Runs a mach command while streaming output to the terminal and capturing it
- * for post-run diagnostics.
+ * Maximum bytes retained per stream in `runMachCapture`. Only the tail of
+ * output is kept so long-lived processes (Storybook, `mach build`) do not
+ * grow the Node heap without bound. 2 MB is enough for post-run error
+ * diagnosis while staying well below the 50 MB cap in `createStreamCollector`.
+ */
+const CAPTURE_TAIL_LIMIT = 2 * 1024 * 1024;
+/**
+ * Runs a mach command while streaming output to the terminal and capturing
+ * the tail of stdout/stderr for post-run diagnostics. Output beyond
+ * {@link CAPTURE_TAIL_LIMIT} is discarded from the head to prevent unbounded
+ * memory growth during long-lived processes like Storybook.
  */
 export async function runMachCapture(args, engineDir, options = {}) {
     const python = await getPython(engineDir);
@@ -55,10 +64,16 @@ export async function runMachCapture(args, engineDir, options = {}) {
         ...(options.env ? { env: options.env } : {}),
         onStdout: (data) => {
             stdout += data;
+            if (stdout.length > CAPTURE_TAIL_LIMIT) {
+                stdout = stdout.slice(-CAPTURE_TAIL_LIMIT);
+            }
             process.stdout.write(data);
         },
         onStderr: (data) => {
             stderr += data;
+            if (stderr.length > CAPTURE_TAIL_LIMIT) {
+                stderr = stderr.slice(-CAPTURE_TAIL_LIMIT);
+            }
             process.stderr.write(data);
         },
     });

package/dist/src/core/markdown-table.d.ts

@@ -0,0 +1,104 @@
+/**
+ * Minimal Markdown pipe-table parser/writer used by token-manager.
+ *
+ * This is **not** a general Markdown parser. It understands exactly the
+ * slice of GitHub-flavoured Markdown that FireForge emits into token docs:
+ *
+ *   - Leading `|` per row, trailing `|` optional.
+ *   - A separator row of `|---|---|...|` immediately after the header.
+ *   - Fenced code blocks (``` / ~~~) are recognised and skipped so that
+ *     literal `|` lines inside code samples are never mistaken for rows.
+ *   - A table ends on the first non-pipe line (blank line, heading, prose).
+ *   - Literal `|` and `\` inside a cell are expressed as `\|` and `\\`
+ *     respectively. The parser treats any other backslash as a literal
+ *     so prose-style backslashes in cell values (e.g. a Windows path)
+ *     still round-trip. Unescaping happens at split time; serialization
+ *     re-applies escapes so round-trips are exact for well-formed input.
+ *
+ * The parser returns **positional metadata** (`startLine`, `endLine`) so
+ * callers can splice the table back into the surrounding document by
+ * range instead of hand-rolled line counters. Mutation operations return
+ * a fresh line array rather than mutating in place, matching the rest of
+ * the file-patching code in this codebase.
+ *
+ * Fallback tolerance: rows with more cells than the header get their
+ * overflow merged into the last column (using a literal `|` separator
+ * between the merged values). This is for the rare case where a FireForge
+ * writer emits an unescaped pipe — the parser still produces a consistent
+ * cell count rather than desynchronising the table. On re-serialize the
+ * merged cell's literal pipes are escaped, so a malformed input becomes
+ * a well-formed output after one round trip.
+ */
+/**
+ * A parsed Markdown pipe table.
+ */
+export interface MarkdownTable {
+    /** Column headers, trimmed. Cells are in document order. */
+    headers: string[];
+    /**
+     * Data rows. Each row is an array with exactly `headers.length` entries,
+     * trimmed. Rows shorter than the header are right-padded with `''`;
+     * longer rows have trailing cells merged into the last column so the
+     * round-trip is faithful.
+     */
+    rows: string[][];
+    /** 0-indexed line number of the header row in the source lines array. */
+    startLine: number;
+    /**
+     * 0-indexed line number *after* the final data row. `lines.slice(
+     * startLine, endLine)` yields exactly the table's lines.
+     */
+    endLine: number;
+}
+/**
+ * Locates the next Markdown table in `lines` starting at or after
+ * `fromLine`, skipping fenced code blocks. Returns `null` when no table
+ * is found.
+ *
+ * @param lines - The full document split by newline
+ * @param fromLine - Line index to start scanning from (inclusive)
+ */
+export declare function findNextTable(lines: string[], fromLine: number): MarkdownTable | null;
+/**
+ * Returns the first table whose header contains **all** of the provided
+ * column names (case-sensitive, order-insensitive). Useful when several
+ * pipe tables share a document and you want to select "the one with a
+ * Mode column".
+ */
+export declare function findTableByColumns(lines: string[], requiredColumns: string[]): MarkdownTable | null;
+/**
+ * Returns the first table that appears **after** a heading matching the
+ * given regex. The heading regex is applied to raw lines (no trimming)
+ * so callers that want leading whitespace flexibility should include
+ * `^\s*` or `^#+\s*` as appropriate.
+ */
+export declare function findTableAfterHeading(lines: string[], headingPattern: RegExp): MarkdownTable | null;
+/**
+ * Serialises a single row using the same `| a | b | c |` layout the rest
+ * of the token docs use. The leading and trailing pipes are always emitted
+ * so that concatenated rows line up consistently. Cell values containing
+ * literal `|` or `\` are escaped as `\|` and `\\` respectively so the
+ * output survives a round-trip through {@link findNextTable}.
+ */
+export declare function serializeRow(cells: string[]): string;
+/**
+ * Inserts a new row into `table.rows` at the given zero-based index. A
+ * negative index counts from the end; `Infinity` appends. Mutates the
+ * table object so callers using {@link rewriteTableRows} see the update.
+ */
+export declare function insertRow(table: MarkdownTable, cells: string[], index: number): void;
+/**
+ * Produces a new `lines` array with the given table region replaced by a
+ * freshly-serialized version of the table's current headers + rows. The
+ * separator row is regenerated from the current header count so edits
+ * that change the column count stay consistent.
+ */
+export declare function rewriteTableRows(lines: string[], table: MarkdownTable): string[];
+/**
+ * Updates a specific cell in the first row whose `keyColumn` cell matches
+ * `keyValue`. Returns `true` when a row was updated.
+ *
+ * Used by token-manager to bump the mode-count table without relying on
+ * brittle regex patterns that assume specific whitespace.
+ */
+export declare function updateCellByKey(table: MarkdownTable, keyColumn: string, keyValue: string, targetColumn: string, newValue: string): boolean;

package/dist/src/core/markdown-table.js

@@ -0,0 +1,266 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Minimal Markdown pipe-table parser/writer used by token-manager.
+ *
+ * This is **not** a general Markdown parser. It understands exactly the
+ * slice of GitHub-flavoured Markdown that FireForge emits into token docs:
+ *
+ *   - Leading `|` per row, trailing `|` optional.
+ *   - A separator row of `|---|---|...|` immediately after the header.
+ *   - Fenced code blocks (``` / ~~~) are recognised and skipped so that
+ *     literal `|` lines inside code samples are never mistaken for rows.
+ *   - A table ends on the first non-pipe line (blank line, heading, prose).
+ *   - Literal `|` and `\` inside a cell are expressed as `\|` and `\\`
+ *     respectively. The parser treats any other backslash as a literal
+ *     so prose-style backslashes in cell values (e.g. a Windows path)
+ *     still round-trip. Unescaping happens at split time; serialization
+ *     re-applies escapes so round-trips are exact for well-formed input.
+ *
+ * The parser returns **positional metadata** (`startLine`, `endLine`) so
+ * callers can splice the table back into the surrounding document by
+ * range instead of hand-rolled line counters. Mutation operations return
+ * a fresh line array rather than mutating in place, matching the rest of
+ * the file-patching code in this codebase.
+ *
+ * Fallback tolerance: rows with more cells than the header get their
+ * overflow merged into the last column (using a literal `|` separator
+ * between the merged values). This is for the rare case where a FireForge
+ * writer emits an unescaped pipe — the parser still produces a consistent
+ * cell count rather than desynchronising the table. On re-serialize the
+ * merged cell's literal pipes are escaped, so a malformed input becomes
+ * a well-formed output after one round trip.
+ */
+/**
+ * Matches the table separator row: optional leading pipe, one or more
+ * dash-only cells (with optional `:` alignment hints) separated by pipes,
+ * optional trailing pipe, allowing whitespace around each cell.
+ */
+const SEPARATOR_ROW = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?\s*$/;
+/**
+ * Returns `true` if the given line looks like a table row (starts with
+ * `|`, ignoring leading whitespace). Does not validate cell contents —
+ * that is the caller's job.
+ */
+function isPipeRow(line) {
+    return /^\s*\|/.test(line);
+}
+/**
+ * Splits a pipe-delimited row into trimmed cell strings.
+ *
+ * Tolerates both `| a | b |` and `| a | b` (no trailing pipe). Leading
+ * empty cells (from a leading `|`) are dropped. A trailing empty cell
+ * (from a trailing `|`) is also dropped so that rows with and without
+ * the trailing pipe produce the same cell count.
+ *
+ * Escape handling: `\|` is consumed as a literal `|` inside a cell, and
+ * `\\` as a literal `\`. Any other backslash stays literal so prose-style
+ * uses of `\` survive untouched. Splitting and unescaping happen in the
+ * same pass so the returned cells are ready to hand back to callers.
+ */
+function splitRow(row) {
+    const trimmed = row.trim();
+    const cells = [];
+    let current = '';
+    for (let i = 0; i < trimmed.length; i++) {
+        const ch = trimmed[i];
+        if (ch === '\\' && i + 1 < trimmed.length) {
+            const next = trimmed[i + 1];
+            if (next === '|' || next === '\\') {
+                current += next;
+                i++;
+                continue;
+            }
+        }
+        if (ch === '|') {
+            cells.push(current);
+            current = '';
+            continue;
+        }
+        current += ch ?? '';
+    }
+    cells.push(current);
+    // Leading `|` gives an empty first segment; drop it.
+    if (cells.length > 0 && cells[0] === '') {
+        cells.shift();
+    }
+    // Trailing `|` gives an empty last segment; drop it.
+    if (cells.length > 0 && cells[cells.length - 1] === '') {
+        cells.pop();
+    }
+    return cells.map((cell) => cell.trim());
+}
+/**
+ * Escapes a cell value so `serializeRow`'s pipe delimiters can be told
+ * apart from literal `|` inside a cell on re-parse. `\` is escaped first
+ * (to `\\`) so that the subsequent `|` → `\|` substitution cannot produce
+ * an already-escaped sequence by accident — i.e. a cell containing
+ * literal `\` followed by literal `|` round-trips as `\\\|`, which
+ * unescape-on-split reads back as `\` + `|`, not as `\|`.
+ */
+function escapeCell(cell) {
+    return cell.replace(/\\/g, '\\\\').replace(/\|/g, '\\|');
+}
+/**
+ * Fits a row of cells against a target column count. Extra cells are
+ * merged into the last column (so a stray `|` in a cell's value does not
+ * desynchronise the table), and missing cells are padded with `''`.
+ */
+function fitRowToColumns(cells, columnCount) {
+    if (columnCount <= 0)
+        return [];
+    if (cells.length === columnCount) {
+        return cells;
+    }
+    if (cells.length < columnCount) {
+        return [...cells, ...Array(columnCount - cells.length).fill('')];
+    }
+    // cells.length > columnCount — merge overflow into the last column.
+    const kept = cells.slice(0, columnCount - 1);
+    const tail = cells.slice(columnCount - 1).join(' | ');
+    return [...kept, tail];
+}
+/**
+ * Locates the next Markdown table in `lines` starting at or after
+ * `fromLine`, skipping fenced code blocks. Returns `null` when no table
+ * is found.
+ *
+ * @param lines - The full document split by newline
+ * @param fromLine - Line index to start scanning from (inclusive)
+ */
+export function findNextTable(lines, fromLine) {
+    let inFence = false;
+    let fenceMarker = null;
+    for (let i = fromLine; i < lines.length; i++) {
+        const line = lines[i] ?? '';
+        const fenceMatch = /^\s*(```|~~~)/.exec(line);
+        if (fenceMatch) {
+            if (!inFence) {
+                inFence = true;
+                fenceMarker = fenceMatch[1] ?? '```';
+            }
+            else if (fenceMarker && line.trim().startsWith(fenceMarker)) {
+                inFence = false;
+                fenceMarker = null;
+            }
+            continue;
+        }
+        if (inFence)
+            continue;
+        if (!isPipeRow(line))
+            continue;
+        const separatorLine = lines[i + 1];
+        if (separatorLine === undefined || !SEPARATOR_ROW.test(separatorLine))
+            continue;
+        const headers = splitRow(line);
+        if (headers.length === 0)
+            continue;
+        const rows = [];
+        let endLine = i + 2;
+        for (let j = i + 2; j < lines.length; j++) {
+            const rowLine = lines[j] ?? '';
+            if (!isPipeRow(rowLine))
+                break;
+            // Another separator line would signal a malformed table — bail.
+            if (SEPARATOR_ROW.test(rowLine))
+                break;
+            rows.push(fitRowToColumns(splitRow(rowLine), headers.length));
+            endLine = j + 1;
+        }
+        return { headers, rows, startLine: i, endLine };
+    }
+    return null;
+}
+/**
+ * Returns the first table whose header contains **all** of the provided
+ * column names (case-sensitive, order-insensitive). Useful when several
+ * pipe tables share a document and you want to select "the one with a
+ * Mode column".
+ */
+export function findTableByColumns(lines, requiredColumns) {
+    let cursor = 0;
+    for (;;) {
+        const table = findNextTable(lines, cursor);
+        if (!table)
+            return null;
+        const headerSet = new Set(table.headers);
+        const matches = requiredColumns.every((column) => headerSet.has(column));
+        if (matches)
+            return table;
+        cursor = table.endLine;
+    }
+}
+/**
+ * Returns the first table that appears **after** a heading matching the
+ * given regex. The heading regex is applied to raw lines (no trimming)
+ * so callers that want leading whitespace flexibility should include
+ * `^\s*` or `^#+\s*` as appropriate.
+ */
+export function findTableAfterHeading(lines, headingPattern) {
+    for (let i = 0; i < lines.length; i++) {
+        if (headingPattern.test(lines[i] ?? '')) {
+            return findNextTable(lines, i + 1);
+        }
+    }
+    return null;
+}
+/**
+ * Serialises a single row using the same `| a | b | c |` layout the rest
+ * of the token docs use. The leading and trailing pipes are always emitted
+ * so that concatenated rows line up consistently. Cell values containing
+ * literal `|` or `\` are escaped as `\|` and `\\` respectively so the
+ * output survives a round-trip through {@link findNextTable}.
+ */
+export function serializeRow(cells) {
+    if (cells.length === 0)
+        return '|';
+    return `| ${cells.map(escapeCell).join(' | ')} |`;
+}
+/**
+ * Inserts a new row into `table.rows` at the given zero-based index. A
+ * negative index counts from the end; `Infinity` appends. Mutates the
+ * table object so callers using {@link rewriteTableRows} see the update.
+ */
+export function insertRow(table, cells, index) {
+    const fitted = fitRowToColumns(cells, table.headers.length);
+    const target = Math.max(0, Math.min(index, table.rows.length));
+    table.rows.splice(target, 0, fitted);
+}
+/**
+ * Produces a new `lines` array with the given table region replaced by a
+ * freshly-serialized version of the table's current headers + rows. The
+ * separator row is regenerated from the current header count so edits
+ * that change the column count stay consistent.
+ */
+export function rewriteTableRows(lines, table) {
+    const headerLine = serializeRow(table.headers);
+    const separatorLine = serializeRow(table.headers.map(() => '---'));
+    const rowLines = table.rows.map((row) => serializeRow(row));
+    return [
+        ...lines.slice(0, table.startLine),
+        headerLine,
+        separatorLine,
+        ...rowLines,
+        ...lines.slice(table.endLine),
+    ];
+}
+/**
+ * Updates a specific cell in the first row whose `keyColumn` cell matches
+ * `keyValue`. Returns `true` when a row was updated.
+ *
+ * Used by token-manager to bump the mode-count table without relying on
+ * brittle regex patterns that assume specific whitespace.
+ */
+export function updateCellByKey(table, keyColumn, keyValue, targetColumn, newValue) {
+    const keyIndex = table.headers.indexOf(keyColumn);
+    const targetIndex = table.headers.indexOf(targetColumn);
+    if (keyIndex === -1 || targetIndex === -1)
+        return false;
+    for (const row of table.rows) {
+        if (row[keyIndex] === keyValue) {
+            row[targetIndex] = newValue;
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=markdown-table.js.map

package/dist/src/core/ownership-table.d.ts

@@ -0,0 +1,53 @@
+import type { PatchMetadata } from '../types/commands/index.js';
+/**
+ * A row in the flat path → owning-patch ownership table.
+ */
+export interface OwnershipRow {
+    path: string;
+    owners: string[];
+    conflict: boolean;
+    conflictReason: 'files-affected' | 'duplicate-create' | null;
+    unmanaged: boolean;
+}
+interface StatusFile {
+    status: string;
+    file: string;
+}
+/**
+ * Builds the flat ownership table from the manifest, worktree status, and
+ * the duplicate-new-file-creation map produced by cross-patch lint.
+ *
+ * Populated from three sources:
+ *
+ *   1. Every path in every patch's `filesAffected` — so managed paths
+ *      show up even when they are not currently modified on disk.
+ *   2. Any worktree status entries not claimed by any patch (flagged as
+ *      `unmanaged`).
+ *   3. Paths created by more than one patch in `new file mode`,
+ *      surfaced as ownership conflicts with
+ *      `conflictReason = 'duplicate-create'`. This is the alignment
+ *      fix between `status --ownership` and `fireforge verify`: a
+ *      queue that `verify` rejects for duplicate `/dev/null → b/foo.js`
+ *      creations was previously reported as clean here because the
+ *      check only walked `filesAffected`, not the patch bodies.
+ *
+ * A path claimed by more than one patch (either via `filesAffected` or
+ * as a duplicate creation) is flagged as `conflict` with the origin
+ * recorded in `conflictReason` so the output can disambiguate.
+ *
+ * @param manifestPatches - Manifest rows, each with its `filesAffected`
+ * @param worktreeFiles - Raw worktree status entries; untracked and
+ *   modified both acceptable
+ * @param newFileCreatorsByPath - Map produced by
+ *   {@link import('../core/patch-lint.js').collectNewFileCreatorsByPath};
+ *   paths with a `.length > 1` owner list become duplicate-create conflicts
+ */
+export declare function buildOwnershipTable(manifestPatches: PatchMetadata[], worktreeFiles: StatusFile[], newFileCreatorsByPath: Map<string, string[]>): OwnershipRow[];
+/**
+ * Renders the ownership table as a GitHub-flavored Markdown pipe table.
+ * Using markdown-table's own serializer would require a seed document to
+ * graft onto, which is overkill for ad-hoc status output; the rendering
+ * here is trivial enough to inline.
+ */
+export declare function renderOwnershipTable(rows: OwnershipRow[]): void;
+export {};

package/dist/src/core/ownership-table.js

@@ -0,0 +1,144 @@
+import { info } from '../utils/logger.js';
+/**
+ * Builds the flat ownership table from the manifest, worktree status, and
+ * the duplicate-new-file-creation map produced by cross-patch lint.
+ *
+ * Populated from three sources:
+ *
+ *   1. Every path in every patch's `filesAffected` — so managed paths
+ *      show up even when they are not currently modified on disk.
+ *   2. Any worktree status entries not claimed by any patch (flagged as
+ *      `unmanaged`).
+ *   3. Paths created by more than one patch in `new file mode`,
+ *      surfaced as ownership conflicts with
+ *      `conflictReason = 'duplicate-create'`. This is the alignment
+ *      fix between `status --ownership` and `fireforge verify`: a
+ *      queue that `verify` rejects for duplicate `/dev/null → b/foo.js`
+ *      creations was previously reported as clean here because the
+ *      check only walked `filesAffected`, not the patch bodies.
+ *
+ * A path claimed by more than one patch (either via `filesAffected` or
+ * as a duplicate creation) is flagged as `conflict` with the origin
+ * recorded in `conflictReason` so the output can disambiguate.
+ *
+ * @param manifestPatches - Manifest rows, each with its `filesAffected`
+ * @param worktreeFiles - Raw worktree status entries; untracked and
+ *   modified both acceptable
+ * @param newFileCreatorsByPath - Map produced by
+ *   {@link import('../core/patch-lint.js').collectNewFileCreatorsByPath};
+ *   paths with a `.length > 1` owner list become duplicate-create conflicts
+ */
+export function buildOwnershipTable(manifestPatches, worktreeFiles, newFileCreatorsByPath) {
+    const ownersByPath = new Map();
+    for (const patch of manifestPatches) {
+        for (const file of patch.filesAffected) {
+            const existing = ownersByPath.get(file) ?? [];
+            existing.push(patch.filename);
+            ownersByPath.set(file, existing);
+        }
+    }
+    // Merge duplicate-new-file-creation findings. The structured helper
+    // returns all new-file paths, so we filter to the ones with more
+    // than one creator. Paths are added to the table even when no patch
+    // listed them in `filesAffected`, because the two-patch duplicate
+    // creation is exactly the shape that manifests as an ownership
+    // conflict without showing up in filesAffected (e.g. drift caused
+    // by manual patches.json editing).
+    const duplicateCreateByPath = new Map();
+    for (const [path, creators] of newFileCreatorsByPath) {
+        if (creators.length <= 1)
+            continue;
+        duplicateCreateByPath.set(path, creators);
+        if (!ownersByPath.has(path)) {
+            ownersByPath.set(path, [...creators]);
+        }
+    }
+    const worktreeSet = new Set(worktreeFiles.map((f) => f.file));
+    const unmanagedOnly = [];
+    for (const path of worktreeSet) {
+        if (!ownersByPath.has(path)) {
+            unmanagedOnly.push(path);
+        }
+    }
+    const rows = [];
+    for (const [path, owners] of ownersByPath) {
+        const duplicateOwners = duplicateCreateByPath.get(path);
+        const isFilesAffectedConflict = owners.length > 1;
+        const isDuplicateCreateConflict = duplicateOwners !== undefined;
+        // Prefer the filesAffected reason when both apply — it's the older
+        // source of drift and the operator will usually want to fix the
+        // manifest rows even when the bodies also duplicate-create.
+        const conflictReason = isFilesAffectedConflict
+            ? 'files-affected'
+            : isDuplicateCreateConflict
+                ? 'duplicate-create'
+                : null;
+        // If the duplicate-create finding introduced new patches not in
+        // filesAffected, merge them into owners so the rendered cell lists
+        // everyone responsible for the conflict, matching what `verify`
+        // prints.
+        const mergedOwners = duplicateOwners
+            ? Array.from(new Set([...owners, ...duplicateOwners])).sort((a, b) => a.localeCompare(b))
+            : owners;
+        rows.push({
+            path,
+            owners: mergedOwners,
+            conflict: isFilesAffectedConflict || isDuplicateCreateConflict,
+            conflictReason,
+            unmanaged: false,
+        });
+    }
+    for (const path of unmanagedOnly) {
+        rows.push({
+            path,
+            owners: [],
+            conflict: false,
+            conflictReason: null,
+            unmanaged: true,
+        });
+    }
+    rows.sort((a, b) => a.path.localeCompare(b.path));
+    return rows;
+}
+/**
+ * Human-readable label for the conflict column. Distinguishes
+ * `files-affected` drift (two manifest rows claiming the same path) from
+ * `duplicate-create` drift (two patches both hitting `/dev/null → b/path`
+ * in their bodies) so the operator can tell at a glance which fix
+ * applies — the former wants `re-export --files`, the latter wants
+ * `patch delete`.
+ */
+function renderConflictCell(row) {
+    if (!row.conflict)
+        return row.unmanaged ? 'unmanaged' : '';
+    if (row.conflictReason === 'duplicate-create')
+        return 'CONFLICT (dup-create)';
+    return 'CONFLICT';
+}
+/**
+ * Renders the ownership table as a GitHub-flavored Markdown pipe table.
+ * Using markdown-table's own serializer would require a seed document to
+ * graft onto, which is overkill for ad-hoc status output; the rendering
+ * here is trivial enough to inline.
+ */
+export function renderOwnershipTable(rows) {
+    if (rows.length === 0) {
+        info('No tracked or modified files.');
+        return;
+    }
+    const pathHeader = 'path';
+    const ownerHeader = 'owning patch';
+    const conflictHeader = 'conflict';
+    const pathWidth = Math.max(pathHeader.length, ...rows.map((r) => r.path.length));
+    const ownerWidth = Math.max(ownerHeader.length, ...rows.map((r) => (r.unmanaged ? 1 : r.owners.join(', ').length)));
+    const conflictWidth = Math.max(conflictHeader.length, ...rows.map((r) => renderConflictCell(r).length), 8);
+    const pad = (text, width) => text + ' '.repeat(width - text.length);
+    info(`| ${pad(pathHeader, pathWidth)} | ${pad(ownerHeader, ownerWidth)} | ${pad(conflictHeader, conflictWidth)} |`);
+    info(`| ${'-'.repeat(pathWidth)} | ${'-'.repeat(ownerWidth)} | ${'-'.repeat(conflictWidth)} |`);
+    for (const row of rows) {
+        const ownerCell = row.unmanaged ? '-' : row.owners.join(', ');
+        const conflictCell = renderConflictCell(row);
+        info(`| ${pad(row.path, pathWidth)} | ${pad(ownerCell, ownerWidth)} | ${pad(conflictCell, conflictWidth)} |`);
+    }
+}
+//# sourceMappingURL=ownership-table.js.map