universal-physics-tensor 9.0.0 → 11.0.0

package/dist/cli/commands/map.js

@@ -19,28 +19,33 @@ import { resolveGraph, coreAnchor, coreLine, groundTruthAnchor, groundTruthLine
 import { emitJson } from '../output.js';
 import { publishedUrl } from '../published-url.js';
 import { UsageError, CliError, EXIT_CHECK_FAILED } from '../errors.js';
+import { integerFlag } from '../numeric-flag.js';
 import { classifyDetermination } from '../determination.js';
 import { parseDiscoveryOpts } from './_discovery-opts.js';
 import * as atlasMap from './_atlas-map.js';
 import { canonicalCheckFailed, conventionLines } from '../conventions.js';
 import { withCatalogEvidence } from '../map-evidence.js';
+import { DISCOVER_MAX_ORDERS_DEFAULT } from '../library-defaults.js';
+/** `--around` reaches this many shared-quantity hops when `--depth` is not given, and at most this many when it is. */
+const DEFAULT_DEPTH = 1;
+const MAX_DEPTH = 10;
 const FLAGS = [
-    sourceFlag('both', 'Which graph to draw: catalog, canonical, both, or poster. poster is the Atlas Phase 3 statement index and is valid only here. This command defaults to both.'),
+    sourceFlag('both', 'Which graph to draw: catalog, canonical, or both. This command defaults to both.'),
     { name: '--format', valueStyle: 'attached', description: 'Output form: text, mermaid, dot, or svg. svg needs the optional @viz-js/viz peer.', defaultValue: 'text' },
     { name: '--out', valueStyle: 'attached', description: 'Write the report to PATH instead of stdout.' },
-    { name: '--max-orders', valueStyle: 'attached', description: 'Magnitude-clash threshold for the --proposed overlay.', defaultValue: '3' },
+    { name: '--max-orders', valueStyle: 'attached', description: 'Magnitude-clash threshold for the --proposed overlay.', defaultValue: DISCOVER_MAX_ORDERS_DEFAULT },
     { name: '--anchor', valueStyle: 'attached', repeatable: true, description: 'Override a numeric anchor as k=v for the --proposed overlay.', defaultValue: 'mass=M_sun' },
     { name: '--proposed', valueStyle: 'none', description: 'Overlay unadjudicated identity-consequence relations.' },
     { name: '--relation', valueStyle: 'attached', description: 'Keep atlas edges whose recorded relation is TYPE.' },
     { name: '--evidence', valueStyle: 'attached', description: 'Keep atlas edges whose derived evidence set contains TAG.' },
     { name: '--around', valueStyle: 'either', description: 'Keep edges within --depth shared-quantity hops of QUANTITY.' },
-    { name: '--depth', valueStyle: 'attached', description: 'Hop count for --around.', defaultValue: '1' },
+    { name: '--depth', valueStyle: 'attached', description: 'Hop count for --around.', defaultValue: String(DEFAULT_DEPTH) },
     { name: '--route', valueStyle: 'either', description: 'Map the atlas route FROM,TO instead of the equation graph.' },
     { name: '--all-routes', valueStyle: 'none', description: 'With --route, list every simple route, shortest first.' },
-    { name: '--max-routes', valueStyle: 'attached', description: 'Cap on --all-routes. The maximum accepted is 1000.', defaultValue: '20' },
+    { name: '--max-routes', valueStyle: 'attached', description: `Cap on --all-routes. The maximum accepted is ${atlasMap.MAX_ROUTES_CEILING}.`, defaultValue: String(atlasMap.DEFAULT_MAX_ROUTES) },
     { name: '--family', valueStyle: 'either', description: 'Map one atlas family by name.' },
     { name: '--observable', valueStyle: 'either', description: 'Map bridges whose recorded text names this observable.' },
-    { name: '--stored', valueStyle: 'none', description: `Derive evidence from ${publishedUrl('data/atlas/witness-results.json')}. That file is not in the published package; the command then names --run.` },
+    { name: '--stored', valueStyle: 'none', description: `Derive evidence from ${publishedUrl('data/atlas/witness-results.json')}. When the file is absent (a checkout or install without data/), the command names --run.` },
     { name: '--run', valueStyle: 'none', description: 'Run the shown bridges\' in-process witnesses now. Exit 3 if one is refuted.' },
     // optionalValue: a bare trailing --equation stores '' so the empty-check in
     // run() owns the diagnostic (old-CLI fidelity: bin/upt.mjs did `a[i+1] ?? ''`
@@ -51,9 +56,16 @@ const FLAGS = [
     { name: '--bind-short', valueStyle: 'none', description: 'Bind a one-letter catalog name in --equation. Without it, those names are reported and not bound.' },
     { name: '--natural', valueStyle: 'none', description: 'Set ħ = c = 1 when a dimension difference is a power of those constants.' },
     { name: '--geometrized', valueStyle: 'none', description: 'With the natural-unit rules, also set G = 1.' },
+    { name: '--communities', valueStyle: 'none', description: 'Also print the layout communities (Louvain, heuristic) of the largest component. A drawing aid, not physics.' },
+    { name: '--cycles', valueStyle: 'none', description: 'Also print the derivation cycles: strongly connected components of the directed source→target quantity graph.' },
+    { name: '--rank-hubs', valueStyle: 'none', description: 'Also rank quantities by betweenness centrality (normalised). Computed only when asked.' },
     JSON_FLAG,
 ];
-const HELP = `upt map [--source=catalog|canonical|both|poster] [--format=text|mermaid|dot|svg]
+/** How many hubs `--rank-hubs` prints in text; `--json` carries every quantity. */
+const HUBS_SHOWN = 10;
+/** Flags that add a structure section to the text and --json forms, and mean nothing on a diagram. */
+const STRUCTURE_FLAGS = ['communities', 'cycles', 'rank-hubs'];
+const HELP = `upt map [--source=catalog|canonical|both] [--format=text|mermaid|dot|svg]
         [--proposed [--anchor=k=v,...] [--max-orders=N]] [--out=PATH]
         [--equation "TARGET = EXPR" [--equation-only] [--verbose] [--bind-short]
         [--natural] [--geometrized]] [--around=QUANTITY [--depth=N]]
@@ -65,15 +77,8 @@ const HELP = `upt map [--source=catalog|canonical|both|poster] [--format=text|me
         --source defaults to 'both' (catalog + canonical) — a pure
         connectivity question gets the honest, all-known-physics answer by
         default; --source=catalog shows the bridge-catalog view alone.
-        --source=poster draws the ATLAS PHASE 3 POSTER INDEX instead of the
-        bridge graph: nodes are STATEMENTS (including the hidden supporting
-        nodes — action principle, Noether, the full Maxwell system, the
-        Lorentz group, the central limit theorem) and boxes are DERIVATIONS
-        (premises in, conclusion out). Associations are drawn DASHED because
-        they assert no relation at all. It also reports any premise naming a
-        statement the registry does not define, and says so out loud when the
-        index is not registered in this build rather than printing an empty
-        map as an answer.
+        --out=PATH writes whatever form was asked for (text, --json or a
+        visual format) to PATH instead of stdout; an empty PATH exits 1.
         --format=mermaid|dot|svg emits the VISUAL map (quantities = nodes,
         equations = junctions colored by status, one subgraph per component).
         text (default) is the unchanged linkage printout. svg renders the dot
@@ -111,7 +116,7 @@ const HELP = `upt map [--source=catalog|canonical|both|poster] [--format=text|me
         from the edges that simply did not match — an unaudited graph must not
         render as a complete answer.
         --around=QUANTITY [--depth=N] keeps only the edges within N
-        shared-quantity hops of QUANTITY (default 1: the edges that use it),
+        shared-quantity hops of QUANTITY (default ${DEFAULT_DEPTH}: the edges that use it),
         in every output form, and prints how many of the source's edges it
         kept: the others are omitted from the view, not absent from the graph.
         --route=FROM,TO and --family=NAME map the ATLAS instead: models and
@@ -127,8 +132,8 @@ const HELP = `upt map [--source=catalog|canonical|both|poster] [--format=text|me
         canonicalRefs record; nothing is inferred from shared quantities.
         --route=FROM,TO --all-routes lists every simple route (no model
         visited twice), shortest first, each with its composition and route
-        claim, and counts the claims; --max-routes=N (default 20, at most
-        1000) bounds the list, and a list cut short says so and says up to
+        claim, and counts the claims; --max-routes=N (default ${atlasMap.DEFAULT_MAX_ROUTES}, at most
+        ${atlasMap.MAX_ROUTES_CEILING}) bounds the list, and a list cut short says so and says up to
         which bridge count it is complete.
         --observable=NAME maps the bridges whose RECORDED preserves text, or
         declared bound translation, names that observable (a whole-word text
@@ -136,7 +141,7 @@ const HELP = `upt map [--source=catalog|canonical|both|poster] [--format=text|me
         preserved, and counts the bridges that record nothing about it;
         --relation/--evidence filter it as they filter a family.
         --stored derives evidence from the committed witness results
-        (${publishedUrl('data/atlas/witness-results.json')}; not in the published package),
+        (${publishedUrl('data/atlas/witness-results.json')}; it ships in data/),
         labelled with the last commit that touched it; --run runs the shown
         bridges' in-process registered witnesses now (exit 3 if any is
         refuted). Either resolves a tag once its witnesses have results; a
@@ -144,6 +149,14 @@ const HELP = `upt map [--source=catalog|canonical|both|poster] [--format=text|me
         unresolved are counted apart.
         Every atlas view states how many of the atlas's models and bridges it
         shows, in text, --json and --format=mermaid|dot|svg.
+        --communities, --cycles and --rank-hubs each add one section to the
+        text report (and a key to --json); they do not apply to a diagram.
+        --communities lists the layout communities (Louvain, heuristic) of the
+        largest component: where a drawing may place quantities together, never
+        a physics claim. --cycles lists the derivation cycles (strongly
+        connected components of the directed source→target quantity graph),
+        where over-determination lives. --rank-hubs ranks quantities by
+        betweenness centrality (normalised; computed only when asked).
         e.g.  upt map --relation=derivation --source=both
               upt map --around=temperature --depth=2 --source=catalog
               upt map --route=model-pendulum,model-lc
@@ -349,8 +362,46 @@ function printEquationReport(api, model, user, out, comparisons = []) {
         }
     }
 }
+/** Compute only the sections asked for; `rankHubs` is the betweenness pass the default path never runs. */
+async function structureSections(api, graph, flags) {
+    return {
+        ...(flags.has('communities') ? { communities: api.communitiesOf(graph) } : {}),
+        ...(flags.has('cycles') ? { cycles: api.derivationCycles(graph) } : {}),
+        ...(flags.has('rank-hubs') ? { hubs: await api.rankHubs(graph) } : {}),
+    };
+}
+/** The text of the structure sections, in flag order; empty when none was asked for. A number goes through `formatQuantity`. */
+function structureLines(s, formatQuantity) {
+    const lines = [];
+    if (s.communities !== undefined) {
+        const c = s.communities;
+        lines.push(`  ${c.method} of the largest component (${c.componentSize} quantities) — a drawing aid, not physics:`);
+        if (c.communities.length === 0)
+            lines.push('     none (the graph has no component)');
+        c.communities.forEach((com, i) => lines.push(`     ${i + 1}. (${com.size}) ${com.quantities.join(', ')}`));
+        lines.push('');
+    }
+    if (s.cycles !== undefined) {
+        const head = s.cycles.length === 0 ? 'none — the quantity graph is acyclic' : String(s.cycles.length);
+        lines.push(`  derivation cycles (strongly connected components of source→target, where over-determination lives): ${head}`);
+        for (const cyc of s.cycles)
+            lines.push(`     {${cyc.quantities.join(', ')}} closed by ${cyc.edges.join(', ')}`);
+        lines.push('');
+    }
+    if (s.hubs !== undefined) {
+        const shown = Math.min(HUBS_SHOWN, s.hubs.length);
+        lines.push(`  hubs by betweenness centrality (normalised; top ${shown} of ${s.hubs.length} quantities; a cut quantity of the drawing, not a central law):`);
+        for (const h of s.hubs.slice(0, shown))
+            lines.push(`     ${h.quantity.padEnd(40)} ${formatQuantity(h.betweenness, 3)}  (degree ${h.degree})`);
+        lines.push('');
+    }
+    // Sections are separated by one blank line; the closing line of the report brings its own.
+    while (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    return lines;
+}
 /** Flags that shape the equation graph, and so mean nothing on an atlas view. */
-const GRAPH_ONLY_FLAGS = ['source', 'around', 'depth', 'equation', 'equation-only', 'proposed', 'max-orders', 'anchor'];
+const GRAPH_ONLY_FLAGS = ['source', 'around', 'depth', 'equation', 'equation-only', 'proposed', 'max-orders', 'anchor', ...STRUCTURE_FLAGS];
 /** Flags that only an atlas view reads. */
 const ATLAS_ONLY_FLAGS = ['all-routes', 'max-routes', 'stored', 'run'];
 async function runAtlasView(ctx, route, family, observable) {
@@ -374,8 +425,9 @@ async function runAtlasView(ctx, route, family, observable) {
     const maxRaw = lastValue(args.flags, 'max-routes');
     if (maxRaw !== undefined && !allRoutes)
         throw new CliError('upt map: --max-routes needs --all-routes');
-    const maxRoutes = maxRaw === undefined ? atlasMap.DEFAULT_MAX_ROUTES : Number(maxRaw);
-    if (!Number.isInteger(maxRoutes) || maxRoutes < 1 || maxRoutes > atlasMap.MAX_ROUTES_CEILING) {
+    // The grammar first (`0x10` is usage, exit 2); the 1..ceiling range after (exit 1).
+    const maxRoutes = maxRaw === undefined ? atlasMap.DEFAULT_MAX_ROUTES : integerFlag('map', '--max-routes', maxRaw);
+    if (maxRoutes < 1 || maxRoutes > atlasMap.MAX_ROUTES_CEILING) {
         throw new CliError(`upt map: --max-routes=${maxRaw} must be an integer from 1 to ${atlasMap.MAX_ROUTES_CEILING}`);
     }
     if (args.flags.has('stored') && args.flags.has('run')) {
@@ -448,7 +500,7 @@ async function runAtlasView(ctx, route, family, observable) {
             writeFileSync(path, src);
         }
         catch (e) {
-            throw new CliError(e.message);
+            throw new CliError(`upt map: ${e.message}`);
         }
         err(`upt: wrote ${fmt} to ${path}`);
     }
@@ -458,7 +510,40 @@ async function runAtlasView(ctx, route, family, observable) {
     err(`upt: ${atlasMap.viewLegend(v)}`);
     return exitCode;
 }
+/**
+ * `--out=PATH` holds for every output form. A visual form writes its diagram
+ * source (handled by the branch that renders it); the text report and the
+ * `--json` envelope are captured here and written whole, so stdout stays
+ * empty and the file holds exactly what stdout would have carried. An empty
+ * PATH exits 1 in every form.
+ */
 async function run(ctx) {
+    const path = lastValue(ctx.args.flags, 'out');
+    const fmt = lastValue(ctx.args.flags, 'format') ?? 'text';
+    if (path === undefined || fmt !== 'text')
+        return runReport(ctx);
+    if (!path)
+        throw new CliError('upt: --out= requires a non-empty PATH');
+    let captured = '';
+    const code = await runReport({
+        ...ctx,
+        out: (line) => {
+            captured += (line ?? '') + '\n';
+        },
+        write: (s) => {
+            captured += s;
+        },
+    });
+    try {
+        writeFileSync(path, captured);
+    }
+    catch (e) {
+        throw new CliError(`upt map: ${e.message}`);
+    }
+    ctx.err(`upt: wrote ${ctx.args.flags.has('json') ? 'json' : 'text'} to ${path}`);
+    return code;
+}
+async function runReport(ctx) {
     const { args, api, out, err, write } = ctx;
     const route = lastValue(args.flags, 'route');
     const family = lastValue(args.flags, 'family');
@@ -473,18 +558,8 @@ async function run(ctx) {
     // map asks a pure connectivity question, so it defaults to --source=both
     // (catalog + canonical) rather than graphs.ts's catalog fallback used by
     // the other --source commands (e.g. discover, which keeps catalog).
-    //
-    // `--source=poster` is a MAP-ONLY source and is resolved HERE, not in
-    // `resolveGraph`. That helper is shared by `discover`, `candidates` and the
-    // rest, and the poster index is not a `BridgeEdge` graph they could analyse;
-    // teaching it a value only one command can use would hand every other command
-    // a source that silently means nothing.
-    const posterMode = lastValue(args.flags, 'source') === 'poster';
     const sourceFlags = args.flags.has('source') ? args.flags : new Map(args.flags).set('source', ['both']);
-    const resolved = posterMode
-        ? { graph: [], label: 'poster (Atlas Phase 3 index)', source: 'poster' }
-        : resolveGraph(api, sourceFlags);
-    const { graph: wholeGraph, label, source } = resolved;
+    const { graph: wholeGraph, label, source } = resolveGraph(api, sourceFlags);
     const around = lastValue(args.flags, 'around');
     const depthRaw = lastValue(args.flags, 'depth');
     if (depthRaw !== undefined && around === undefined)
@@ -492,11 +567,10 @@ async function run(ctx) {
     let focus = null;
     let fullGraph = wholeGraph;
     if (around !== undefined) {
-        if (posterMode)
-            throw new CliError('upt map: --around focuses a quantity graph; the poster index has statements, not quantities');
-        const depth = depthRaw === undefined ? 1 : Number(depthRaw);
-        if (!Number.isInteger(depth) || depth < 1 || depth > 10)
-            throw new CliError(`upt map: --depth=${depthRaw} must be an integer from 1 to 10`);
+        // The grammar first (`1e1` is usage, exit 2); the 1..MAX_DEPTH range after (exit 1).
+        const depth = depthRaw === undefined ? DEFAULT_DEPTH : integerFlag('map', '--depth', depthRaw);
+        if (depth < 1 || depth > MAX_DEPTH)
+            throw new CliError(`upt map: --depth=${depthRaw} must be an integer from 1 to ${MAX_DEPTH}`);
         const known = new Set(wholeGraph.flatMap((e) => [...e.sources.map((q) => q.name), e.target.name]));
         const name = api.resolveQuantityName(around, known);
         if (name === null) {
@@ -510,12 +584,6 @@ async function run(ctx) {
         ? null
         : `focused: ${focus.kept} of ${focus.of} edges within ${focus.depth} hop(s) of '${focus.around}' [${label}]; ` +
             'the rest are omitted from this view, not absent from the graph';
-    // The poster's own report line: what it contributed, or why it contributed
-    // nothing (design note §6). Computed once; printed by every output form.
-    const posterValidation = posterMode ? api.validatePoster(api.POSTER_GRAPH) : null;
-    const posterNote = posterMode
-        ? api.describePosterSource(api.POSTER_GRAPH, posterValidation)
-        : null;
     // The two overlay filters. Parsed BEFORE anything else is computed so a bad
     // value costs nothing and always exits 1.
     const relation = parseFilter(lastValue(args.flags, 'relation'), RELATION_TYPES, '--relation');
@@ -532,12 +600,10 @@ async function run(ctx) {
     // selects, only about how much they were asked to count.
     const { kept: graph, stats: edgeStats } = api.filterEdges(fullGraph, filterOpts);
     // Audit I3: what "anchored" means here, and the discovery ground truth when --proposed ran the funnel.
-    const anchor = posterMode
-        ? null
-        : {
-            core: coreAnchor(graph),
-            ...(args.flags.has('proposed') ? { groundTruth: groundTruthAnchor(api, parseDiscoveryOpts(api, args.flags)) } : {}),
-        };
+    const anchor = {
+        core: coreAnchor(graph),
+        ...(args.flags.has('proposed') ? { groundTruth: groundTruthAnchor(api, parseDiscoveryOpts(api, args.flags)) } : {}),
+    };
     const edgeLegend = api.formatFilterLegend(edgeStats);
     const fmtValues = args.flags.get('format');
     const fmt = fmtValues && fmtValues.length > 0 ? fmtValues[fmtValues.length - 1] : 'text';
@@ -545,6 +611,13 @@ async function run(ctx) {
     if (isJson && fmt !== 'text') {
         throw new UsageError('upt: pick one output form: --json or --format');
     }
+    const structureAsked = STRUCTURE_FLAGS.filter((f) => args.flags.has(f));
+    if (structureAsked.length > 0 && fmt !== 'text') {
+        const named = structureAsked.map((f) => `--${f}`).join(', ');
+        throw new UsageError(`upt map: ${named} print${structureAsked.length === 1 ? 's' : ''} text or --json; ${structureAsked.length === 1 ? 'it does' : 'they do'} not apply to --format=${fmt}`);
+    }
+    // Computed only when asked, over the same filtered edge list the linkage map reads.
+    const structure = await structureSections(api, graph, args.flags);
     // --equation injects a user-supplied "TARGET = EXPR" as a 'user' junction.
     let user = null;
     let comparisons = [];
@@ -567,6 +640,9 @@ async function run(ctx) {
                 : args.flags.has('natural')
                     ? 'natural'
                     : undefined;
+            if (args.flags.has('geometrized') && args.flags.has('natural')) {
+                throw new UsageError('upt map: pick one unit mode: --natural (ħ = c = 1) or --geometrized (ħ = c = G = 1)');
+            }
             ({ user, comparisons } = await analyzeEquation(api, equation, graph, {
                 bindShortNames: args.flags.has('bind-short'),
                 ...(units === undefined ? {} : { units }),
@@ -582,17 +658,11 @@ async function run(ctx) {
     // The same classification `upt derive` uses. A canonical agreement stays 0.
     // A catalog target that was not established exits 3. An unbound target stays 0.
     const exitCode = user === null ? 0 : equationDetermination(user, comparisons).exit;
-    const overlay = (extra) => [
-        // Ranked from the UNFILTERED graph: the proposal set is a property of the
-        // whole catalog, and the model then judges each overlay junction under the
-        // same filter as every other junction.
-        ...(args.flags.has('proposed') ? proposedJunctions(api, wholeGraph, args.flags) : []),
-        // The poster enters as an overlay for exactly the reason the design note
-        // gives: an overlay is FILTERED, clustered and legended like every other
-        // junction, so a poster source cannot quietly bypass --relation/--evidence.
-        ...(posterMode ? api.posterJunctions(api.POSTER_GRAPH) : []),
-        ...extra,
-    ];
+    // Ranked from the UNFILTERED graph: the proposal set is a property of the
+    // whole catalog, and the model then judges each overlay junction under the
+    // same filter as every other junction. Computed once for every output form.
+    const proposed = args.flags.has('proposed') ? proposedJunctions(api, wholeGraph, args.flags) : null;
+    const overlay = (extra) => [...(proposed ?? []), ...extra];
     if (isJson) {
         const linkage = api.linkageMap(graph);
         let landing;
@@ -619,13 +689,14 @@ async function run(ctx) {
         emitJson({
             command: 'map',
             source,
-            ...(anchor !== null ? { anchor } : {}),
+            anchor,
             result: {
                 ...(equation != null && (equationOnly || !args.flags.has('verbose')) ? {} : { linkage }),
-                ...(posterMode ? { poster: { note: posterNote, ...posterValidation } } : {}),
+                ...(proposed === null ? {} : { proposed: proposed.map((p) => ({ id: p.id, target: p.target, sources: p.sources })) }),
                 ...(edgeLegend !== null ? { filter: edgeStats } : {}),
                 ...(focus !== null ? { focus } : {}),
                 ...(user ? { landing, userEquation } : {}),
+                ...structure,
             },
         }, write);
         return exitCode;
@@ -660,7 +731,7 @@ async function run(ctx) {
                 writeFileSync(path, src);
             }
             catch (e) {
-                throw new CliError(e.message);
+                throw new CliError(`upt map: ${e.message}`);
             }
             err(`upt: wrote ${fmt} (${model.junctions.length} junctions, ${model.clusters.length} clusters) to ${path}`);
         }
@@ -669,8 +740,6 @@ async function run(ctx) {
         }
         // Legend and landing report go to stderr so stdout/--out stays pure diagram
         // source. The diagram itself also carries the legend (see `buildVizModel`).
-        if (posterNote !== null)
-            err(`upt: ${posterNote}`);
         if (focusLine !== null)
             err(`upt: ${focusLine}`);
         if (model.filterLegend !== null)
@@ -682,30 +751,6 @@ async function run(ctx) {
     if (fmt !== 'text') {
         throw new CliError(`upt: unknown --format='${fmt}' (expected: text | mermaid | dot | svg)`);
     }
-    if (posterMode) {
-        const model = api.buildVizModel(fullGraph, {
-            title: `UPT physics map — ${label}`,
-            extraJunctions: overlay(user ? [user.junction] : []),
-            ...filterOpts,
-        });
-        out(`
-Poster index — statements and the derivations between them  [source: ${label}]`);
-        out(`  ${posterNote}`);
-        out(`  (${model.junctions.length} junctions over ${model.clusters.length} clusters; ` +
-            `${api.POSTER_GRAPH.derivations.length} derivations, ` +
-            `${api.POSTER_GRAPH.associations.length} associations)`);
-        if (model.filterLegend !== null)
-            out(`  ${model.filterLegend}`);
-        for (const d of posterValidation.dangling) {
-            out(`  ⚠ '${d.derivation}' names '${d.missing}' as a ${d.role}, and nothing defines it.`);
-        }
-        if (user) {
-            out(`
-Your equation:  ${user.junction.label}`);
-            printEquationReport(api, model, user, out, comparisons);
-        }
-        return exitCode;
-    }
     // --equation: the verdict on the user's equation is the answer asked for, so it
     // comes BEFORE the linkage map, not after ~45 lines of it (persona finding N4).
     if (user) {
@@ -728,6 +773,18 @@ Your equation:  ${user.junction.label}`);
     out(`  ${coreLine(anchor.core)}`);
     if (anchor.groundTruth)
         out(`  proposals: ${groundTruthLine(anchor.groundTruth)}`);
+    if (proposed !== null) {
+        // The overlay the visual forms draw, listed here: an unadjudicated identity consequence is a
+        // proposal, never a catalog edge. Each names its target and the quantities it would relate.
+        out(`  proposed relations (${proposed.length}, unadjudicated identity consequences; not catalog edges):`);
+        for (const p of proposed) {
+            // No free input: every governing quantity of the derived relation is a registered constant.
+            const sources = p.sources.length === 0 ? '{} (no sources: every input is a registered constant)' : `{${p.sources.join(', ')}}`;
+            out(`     ${p.id}: ${p.target} ← ${sources}`);
+        }
+        if (proposed.length === 0)
+            out('     (none at this anchor and --max-orders)');
+    }
     out('');
     if (focusLine !== null)
         out(`  ${focusLine}`);
@@ -740,7 +797,13 @@ Your equation:  ${user.junction.label}`);
         out(`     link hubs: ${c.hubs.join(', ')}\n`);
     }
     out(`  ○ isolated (${m.isolated.length}) — share no quantity with any other edge:`);
-    out(`     ${m.isolated.join(', ')}`);
+    out(`     ${m.isolated.length === 0 ? 'none' : m.isolated.join(', ')}`);
+    const structureText = structureLines(structure, api.formatQuantity);
+    if (structureText.length > 0) {
+        out('');
+        for (const line of structureText)
+            out(line);
+    }
     out('\n  (a structural map — shared-quantity connectivity, NOT a credibility signal)');
     return exitCode;
 }