tickmarkr 2.6.6 → 2.6.8

package/dist/tui/ink/fleet-app.js

@@ -49,7 +49,7 @@ const REACH_CHOICES = [
     { id: "out-workers", label: "out · workers", gloss: "workers skip it; judge/review/consult unaffected" },
     { id: "out-all", label: "out · all seats", gloss: "no seat routes here" },
 ];
-export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts = {}, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories = [], reviewOverlay, reloadGuard, stagedRouting, holderOf, entry = "probe", initialJudge = "", judgeSeats = [], viewRows = Number.POSITIVE_INFINITY, frameColumns = 100, frameRows, ...initialDenyProps }) {
+export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts = {}, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories = [], reviewOverlay, layerStamp, reloadGuard, stagedRouting, holderOf, entry = "probe", initialJudge = "", judgeSeats = [], viewRows = Number.POSITIVE_INFINITY, frameColumns = 100, frameRows, ...initialDenyProps }) {
     const { exit } = useApp();
     const [, setRevision] = useState(0);
     // the props are the fleet command's contract, one per schema-enumerated scope (initialDeny…),
@@ -137,21 +137,51 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
     // the STAGED policy (fleet loads the candidate bytes; see stagedRouting) and the recorded
     // identity — never literal membership of the staged sets, which missed identity, bare-model and
     // family entries and could not tell an allowlist exclusion from a deny.
-    let routingMemo = null;
+    // B-KEYS (D-1338): the staged CONTENT every row and the staged policy derive from — the deny sets,
+    // the allow complement, classifications, efforts and seeds, read raw off ui (the provenance a
+    // review folds is a pure function of them). Computed per call, never per render: a handler
+    // mutates ui and reads rows in the same tick, before bump.
+    const stagedKey = () => JSON.stringify([
+        DENY_SCOPES.map((scope) => [...ui[scope.key]].sort()),
+        [...ui.allowOut].sort(),
+        ui.classifications,
+        ui.efforts,
+        ui.seededAllowOut,
+    ]);
+    // ponytail: both memos live in refs keyed on stagedKey — a render-local memo reset on every keypress,
+    // so each cursor move reloaded the policy and re-derived ~800 rows' reach (B-KEYS). A cursor move,
+    // a filter, showAll or an overlay never recompute a row; any staged edit changes the key and
+    // recomputes every group. Ceiling: one JSON.stringify of the staged sets per lookup (µs); a dirty
+    // counter bumped at every mutation site if a fleet ever outgrows it.
+    const routingMemo = useRef(null);
     const stagedPolicy = () => {
+        const key = memoKey();
+        const memo = routingMemo.current;
+        if (memo?.key === key)
+            return memo.policy;
         const deny = stagedDeny();
         const stage = stagedMetadata();
-        const key = JSON.stringify([deny, stage]);
-        if (routingMemo?.key !== key) {
-            routingMemo = {
-                key,
-                policy: stagedRouting
-                    ? stagedRouting(deny, stage)
-                    : { ok: true, routing: { deny: denyBlockFrom(denyLists()) } },
-            };
-        }
-        return routingMemo.policy;
+        const policy = stagedRouting
+            ? stagedRouting(deny, stage)
+            : { ok: true, routing: { deny: denyBlockFrom(denyLists()) } };
+        routingMemo.current = { key, policy };
+        return policy;
     };
+    const rowsMemo = useRef({ key: "", byAdapter: new Map() });
+    // B-KEYS r2 (D-1446): staged content alone does not identify a row — the rows also derive from the loaded
+    // overlay layers (stagedRouting and holderOf read both files) and the props they read. Once per render a
+    // generation moves when the layer bytes or one of those props changes, and both memos key on it beside the
+    // staged content: a layer written mid-session shows on the next frame, as on the base, while a cursor move
+    // over unchanged layers still derives nothing. Cost: one read of each overlay per frame (the B2 previewCfg key).
+    const layers = useRef({ stamp: "", inputs: [], gen: 0 });
+    {
+        const stamp = layerStamp?.() ?? "";
+        const inputs = [modelGroups, stagedRouting, holderOf];
+        if (stamp !== layers.current.stamp || inputs.some((input, at) => input !== layers.current.inputs[at])) {
+            layers.current = { stamp, inputs, gen: layers.current.gen + 1 };
+        }
+    }
+    const memoKey = () => `${layers.current.gen}\u0000${stagedKey()}`;
     // OBS-1099 add.1: the browser's deny discovery ranges over the schema-enumerated scopes (the
     // route collector names its four paths by hand, so a scope the schema gains would never render
     // or lift here). A flat scope reaches every seat; a nested one only the seat its block names
@@ -183,20 +213,31 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
             }),
         };
     };
-    // OBS-1099 review: a displayed row may fold several discovered gateway ids (foldedModels);
-    // each folded id is a real channel the policy matches on its own, so every one but a row's
-    // own id counts as a sibling — an entry covering a folded id is shared, never row-owned
-    const displayedChannels = () => modelGroups.flatMap((group) => group.rows
-        .flatMap((other) => (other.foldedModels?.length ? other.foldedModels : [other.model])
-        .map((model) => ({ adapter: group.adapter, model, identity: other.evidence?.identity }))));
+    // T5: the real channels a displayed row stands for — every collapsed variant and catalog-fold
+    // constituent fleet derived from the cached doctor list, each with its own identity; a row without
+    // them stands for its folded ids, else its reference real id (classifyModel) or its own. Display labels
+    // are never channels.
+    const membersOf = (adapter, row) => {
+        const listed = row.members?.length ? row.members
+            : (row.foldedModels?.length ? row.foldedModels : [row.classifyModel ?? row.model]).map((model) => ({ model, identity: row.evidence?.identity }));
+        // one channel per real id: a repeated id is one member, so a grouped act takes ONE reason from it
+        return listed.filter((member, at) => listed.findIndex((other) => other.model === member.model) === at)
+            .map((member) => ({ adapter, model: member.model, ...(member.identity !== undefined ? { identity: member.identity } : {}) }));
+    };
+    // OBS-1099 review: a displayed row may fold several discovered gateway ids; each real member is a
+    // channel the policy matches on its own, so every one but a channel itself counts as a sibling —
+    // an entry covering another member is shared, never channel-owned (grouping never privatizes it)
+    const displayedChannels = () => modelGroups.flatMap((group) => group.rows.flatMap((other) => membersOf(group.adapter, other)));
     const siblingsOf = (self) => displayedChannels()
         .filter((other) => other.adapter !== self.adapter || other.model !== self.model);
     // Judge c3 (R107): exactly ONE selected entry per act — the channel's adapter:model key when it
-    // is a candidate, else the first candidate in sorted order; only an entry no sibling matches
-    const selectOwn = (entries, self) => {
+    // is a candidate, else the first candidate in sorted order; only an entry no sibling matches.
+    // T5: matched as production matches the list — a deny entry with family matching, an allow-complement
+    // entry exactly as routing.allow admits (`fake:C-low` never reaches a bare `fake:C` there)
+    const selectOwn = (entries, self, family = true) => {
         const others = siblingsOf(self);
-        const candidates = [...entries].filter((entry) => entryMatchesChannel(entry, self, true)
-            && !others.some((other) => entryMatchesChannel(entry, other, true)));
+        const candidates = [...entries].filter((entry) => entryMatchesChannel(entry, self, family)
+            && !others.some((other) => entryMatchesChannel(entry, other, family)));
         const id = `${self.adapter}:${self.model}`;
         return candidates.includes(id) ? id : candidates.sort()[0];
     };
@@ -286,11 +327,48 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         const shared = isAdapterWide(scope.entry, self) || covers.length > 1;
         return { entry: scope.entry, scope: scope.configPath, covers, shared, edits: reachEdits(owned) };
     };
+    // T5: a grouped row's reach over EVERY real member — the whole-group state only when every member
+    // holds it; otherwise the most-excluded member's reach, marked partial, each member-specific reason
+    // prefixed with its real id. A one-member row is exactly its channel's reach.
+    const rowReach = (members) => {
+        const each = members.map((member) => ({ model: member.model, ...reachFor(member.adapter, member.model, member.identity) }));
+        if (each.length === 1) {
+            const { model: _model, ...only } = each[0];
+            return { ...only, partial: false };
+        }
+        const folded = foldReach(each);
+        const uniform = each.every((channel) => channel.reach === each[0].reach);
+        return {
+            reach: uniform ? each[0].reach : folded.reach,
+            reasons: folded.reasons,
+            partial: folded.partial,
+            uncoveredAlias: each.some((channel) => channel.uncoveredAlias),
+            held: [...new Set(each.flatMap((channel) => channel.held))],
+        };
+    };
+    // T5: the covering entry a grouped row names — a shared one first, so l owns it
+    const rowCovering = (members) => {
+        const found = members.map(coveringFor).filter((covering) => covering !== undefined);
+        return found.find((covering) => covering.shared) ?? found[0];
+    };
+    // B-KEYS: one derivation per group per staged state — the memo above hands every later pass
+    // (visibleCount per rail row, modelRows, the hidden and folded counts, a handler's lookup) the
+    // same rows; the returned array is read, never mutated, by every caller.
     const groupRows = (group) => {
+        const key = memoKey();
+        if (rowsMemo.current.key !== key)
+            rowsMemo.current = { key, byAdapter: new Map() };
+        const memo = rowsMemo.current.byAdapter;
+        const rows = memo.get(group.adapter) ?? deriveGroupRows(group);
+        memo.set(group.adapter, rows);
+        return rows;
+    };
+    const deriveGroupRows = (group) => {
         const rows = group.rows.map((row) => {
+            const members = membersOf(group.adapter, row);
             const staged = ui.classifications.find((classification) => classification.adapter === group.adapter
-                && (classification.model === row.model || classification.model === row.classifyModel));
-            const reach = reachFor(group.adapter, row.model, row.evidence?.identity);
+                && (classification.model === row.model || members.some((member) => member.model === classification.model)));
+            const reach = rowReach(members);
             return {
                 adapter: group.adapter,
                 model: row.model,
@@ -302,16 +380,17 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
                 classifyModel: row.classifyModel,
                 variants: row.variants,
                 foldedModels: row.foldedModels,
+                ...(row.members ? { members: row.members } : {}),
                 score: row.score,
                 denied: reach.reach !== "in",
                 ...reach,
                 // OBS-1099 item 2 (review round 2): every row is covered the same way — an alias through
                 // its identity, a plain row by a bare-model or adapter entry — so a shared bare-model
                 // entry across adapters has the one owning control too
-                covering: coveringFor({ adapter: group.adapter, model: row.model, identity: row.evidence?.identity }),
+                covering: rowCovering(members),
             };
         });
-        const known = new Set(rows.flatMap((row) => row.classifyModel ? [row.model, row.classifyModel] : [row.model]));
+        const known = new Set(group.rows.flatMap((row) => [row.model, ...membersOf(group.adapter, row).map((member) => member.model)]));
         for (const staged of ui.classifications) {
             if (staged.adapter === group.adapter && !known.has(staged.model)) {
                 const reach = reachFor(group.adapter, staged.model);
@@ -448,27 +527,29 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
     // its classification — the ownAllow spelling Space clears — so it can be admitted in this session.
     // Re-staging a classification replaces its seed; a row the allow form admits seeds nothing. A row a
     // flat deny ALSO excludes still seeds, so successive owning lifts (deny, then allow) admit it.
-    const seedAllow = (adapter, model, displayModel) => {
-        // ponytail: a collapsed variant row's allow entry would name no channel (its display name is not the real
-        // model), so it is not seeded for same-session admission — classify, save, then admit next session;
-        // full grouped-row membership (collapse + catalog fold) is 2.6.7 (T10 owed review F1, D-1016)
-        if (model !== displayModel)
-            return;
-        const identity = groupOf(adapter)?.rows.find((row) => row.model === displayModel)?.evidence?.identity;
-        const self = { adapter, model: displayModel, ...(identity !== undefined ? { identity } : {}) };
+    // T5: one seed per REAL member of a grouped row (collapsed variants, catalog-fold constituents), keyed and
+    // spelled by its real id with its own identity — the display label never names a channel.
+    const seedAllow = (self, displayModel) => {
         const policy = stagedPolicy();
         if (!policy.ok || !exclusionsOf(self, policy.routing, "judge").some((scope) => scope.by === "allow"))
             return;
-        const entry = selectOwn(ui.allowOut, self) ?? `${adapter}:${displayModel}`;
+        const entry = selectOwn(ui.allowOut, self, false) ?? `${self.adapter}:${self.model}`;
         ui.allowOut = new Set([...ui.allowOut, entry]);
         ui.seededAllowOut = [
-            ...ui.seededAllowOut.filter((seed) => seed.adapter !== adapter || seed.model !== model),
-            { adapter, model, displayModel, ...(identity !== undefined ? { identity } : {}), entry },
+            ...ui.seededAllowOut.filter((seed) => seed.adapter !== self.adapter || seed.model !== self.model),
+            { adapter: self.adapter, model: self.model, displayModel, ...(self.identity !== undefined ? { identity: self.identity } : {}), entry },
         ];
     };
+    // T5: the real members a classification of this browser row stages — a row the browser never listed
+    // (n adds one) is its own one member
+    const classifiedMembers = (adapter, displayModel) => {
+        const row = groupOf(adapter)?.rows.find((candidate) => candidate.model === displayModel);
+        return row ? membersOf(adapter, row) : [{ adapter, model: displayModel }];
+    };
     const stageSuggested = (adapter, rows, firstTouch) => {
-        for (const row of rows)
-            seedAllow(adapter, row.model, row.displayModel);
+        for (const row of rows) {
+            seedAllow({ adapter, model: row.model, ...(row.identity !== undefined ? { identity: row.identity } : {}) }, row.displayModel);
+        }
         ui.classifications = [
             ...ui.classifications,
             ...rows.map((row) => ({
@@ -521,18 +602,23 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         }
         setOverlay({ ...base, stage: "channel", vendor: group.vendor });
     };
+    // T5: the picked tier and provenance land on EVERY real member of the row, each with its own seed —
+    // classifyModel stays the reference id the suggestion and the overlay title name
     const applyClassification = (overlay) => {
         const answered = overlay.vendor ? ui.channelByAdapter[overlay.adapter] : undefined;
-        seedAllow(overlay.adapter, overlay.model, overlay.displayModel ?? overlay.model);
+        const displayModel = overlay.displayModel ?? overlay.model;
+        const members = classifiedMembers(overlay.adapter, displayModel);
+        for (const member of members)
+            seedAllow(member, displayModel);
         ui.classifications = [
             ...ui.classifications,
-            {
+            ...members.map((member) => ({
                 adapter: overlay.adapter,
-                model: overlay.model,
+                model: member.model,
                 tier: TIERS[overlay.tierAt],
                 note: overlay.note.trim(),
                 ...(overlay.vendor && answered ? { vendor: overlay.vendor, channel: answered } : {}),
-            },
+            })),
         ];
         setOverlay(null);
     };
@@ -560,8 +646,9 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
     // channel-specific one carries its channel, so a partial exclusion is never intersected away.
     const adapterReach = (id) => {
         const group = modelGroups.find((candidate) => candidate.adapter === id);
-        const channels = (group?.rows ?? []).flatMap((row) => (row.foldedModels?.length ? row.foldedModels : [row.model])
-            .map((model) => ({ model, ...reachFor(id, model, row.evidence?.identity) })));
+        // T5: every real member of every row — a collapsed or folded row's display label is no channel
+        const channels = (group?.rows ?? []).flatMap((row) => membersOf(id, row))
+            .map((channel) => ({ model: channel.model, ...reachFor(id, channel.model, channel.identity) }));
         if (channels.length === 0) {
             // ponytail: a rail entry with no probed channels has only its own literal entries to show
             const reasons = [
@@ -574,6 +661,11 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
                     : NESTED_ADAPTER_SCOPES.some((scope) => ui[scope.key].has(id)) ? "out-workers" : "in";
             return { reach, reasons, partial: false };
         }
+        return foldReach(channels);
+    };
+    // the rail's (and a grouped row's) fold over its real channels — most-excluded reach, partial when they
+    // disagree, shared reasons once and channel-specific ones carrying their channel
+    function foldReach(channels) {
         const unknown = channels.find((channel) => channel.reach === "unknown");
         if (unknown)
             return { reach: "unknown", reasons: unknown.reasons, partial: false };
@@ -588,7 +680,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
             .filter((reason) => !shared.includes(reason))
             .map((reason) => `${channel.model}: ${reason}`));
         return { reach, reasons: [...shared, ...own], partial };
-    };
+    }
     const describeReach = (state) => state.partial ? `${state.reach} (partial: not every channel)` : state.reach;
     // OBS-1099 items 1 and 4: one picker choice changes exactly ONE selected entry in ONE scope —
     // added, cleared, or re-scoped between the workers list and the flat list — then the row's
@@ -678,90 +770,106 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         if (!row)
             return;
         const id = `${row.adapter}:${row.model}`;
-        const self = { adapter: row.adapter, model: row.model, identity: row.evidence?.identity };
-        // LEG2-T3 round 2 finding 1 / D-233 / D-235 (review round 10): ONE ordered selector —
-        // ownedDenies — feeds the detail line AND every Space edit, so the entry named is the entry
-        // edited: a clear takes its head (own key first, then collector order); a demotion takes its
-        // first flat entry, a promotion its first workers entry; a bare adapter id or a sibling's
-        // entry is never in it. OBS-1046: an allow exclusion is the LAST reason taken, never together
-        // with an authored deny.
-        const edits = reachEdits(ownedDenies(self));
-        const ownAllow = () => {
-            const fromAllow = selectOwn(ui.allowOut, self);
-            return fromAllow === undefined ? undefined : { entry: fromAllow, scope: "routing.allow" };
-        };
-        const ownFlat = () => edits.demote ?? ownAllow();
-        const ownWorkers = () => edits.promote;
-        const takeFlat = (found) => {
-            const scope = scopeOf(found.scope);
-            if (scope)
-                ui[scope.key] = without(ui[scope.key], found.entry);
-            else
-                ui.allowOut = without(ui.allowOut, found.entry);
-        };
-        const refuse = (reachLabel) => {
-            // OBS-1099 item 2: a covered row names the covering entry, every identity it covers, and
-            // the ONE control that lifts it — the T1 refusal wording stays in front of it
-            if (row.covering?.shared) {
-                // the notice clips at the browser width; the detail line and the l overlay list every identity
-                ui.notice = `${id} stays ${reachLabel} — ${row.covering.scope} (${row.covering.entry}) covers ${row.covering.covers.length} channels — Space edits only this channel's own entries; l lists and lifts it`;
-                return;
+        // T5: a grouped row's act is the same one-reason act on EVERY real member, each decided from the reach
+        // it held BEFORE this act — a sibling's fresh entry that also matches a member's recorded identity never
+        // turns that member's own addition into "already" (review D-1081) — while every removal still takes only
+        // an entry the member owns alone over the staged sets; a member a shared entry keeps out is named and left
+        const members = membersOf(row.adapter, row);
+        const before = members.map((self) => (members.length === 1
+            ? { reach: row.reach, reasons: row.reasons, covering: row.covering }
+            : { ...reachFor(self.adapter, self.model, self.identity), covering: coveringFor(self) }));
+        const outcomes = members.map((self, at) => {
+            const memberId = `${self.adapter}:${self.model}`;
+            const { reasons, covering } = before[at];
+            // LEG2-T3 round 2 finding 1 / D-233 / D-235 (review round 10): ONE ordered selector —
+            // ownedDenies — feeds the detail line AND every Space edit, so the entry named is the entry
+            // edited: a clear takes its head (own key first, then collector order); a demotion takes its
+            // first flat entry, a promotion its first workers entry; a bare adapter id or a sibling's
+            // entry is never in it. OBS-1046: an allow exclusion is the LAST reason taken, never together
+            // with an authored deny.
+            const edits = reachEdits(ownedDenies(self));
+            // review D-1081 add.: the seed this session generated for this member is its own even when a peer
+            // member's recorded identity also reaches it (C-high recorded as C-low) — never authored, and lifting
+            // it admits only this act's members; a seed any channel outside the row matches stays shared
+            const ownSeed = () => ui.seededAllowOut.find((seed) => seed.adapter === self.adapter && seed.model === self.model
+                && ui.allowOut.has(seed.entry)
+                && !siblingsOf(self).some((other) => !members.some((peer) => peer.adapter === other.adapter && peer.model === other.model)
+                    && entryMatchesChannel(seed.entry, other, false)))?.entry;
+            const ownAllow = () => {
+                const fromAllow = selectOwn(ui.allowOut, self, false) ?? ownSeed();
+                return fromAllow === undefined ? undefined : { entry: fromAllow, scope: "routing.allow" };
+            };
+            const ownFlat = () => edits.demote ?? ownAllow();
+            const ownWorkers = () => edits.promote;
+            const takeFlat = (found) => {
+                const scope = scopeOf(found.scope);
+                if (scope)
+                    ui[scope.key] = without(ui[scope.key], found.entry);
+                else
+                    ui.allowOut = without(ui.allowOut, found.entry);
+            };
+            const refuse = (reachLabel) => {
+                // OBS-1099 item 2: a covered row names the covering entry, every identity it covers, and
+                // the ONE control that lifts it — the T1 refusal wording stays in front of it
+                if (covering?.shared) {
+                    // the notice clips at the browser width; the detail line and the l overlay list every identity
+                    return { refused: `${memberId} stays ${reachLabel} — ${covering.scope} (${covering.entry}) covers ${covering.covers.length} channels — Space edits only this channel's own entries; l lists and lifts it` };
+                }
+                const shared = ui.denyAdapters.has(row.adapter) || ui.allowOut.has(row.adapter) || ui.denyWorkersAdapters.has(row.adapter)
+                    ? `every ${row.adapter} channel is out together — set the adapter's reach on the rail`
+                    : "a shared entry covers other channels too";
+                return { refused: `${memberId} stays ${reachLabel} — ${reasons.join("; ")} — Space edits only this channel's own entries; ${shared}` };
+            };
+            const reach = before[at].reach;
+            const outAll = reach === "out-all" || reach === "out-allow";
+            if (choice === "out-workers" && reach === "in") {
+                ui.denyWorkersModels = withEntry(ui.denyWorkersModels, memberId);
+                return { edit: `added ${memberId} to routing.deny.workers.models` };
             }
-            const shared = ui.denyAdapters.has(row.adapter) || ui.allowOut.has(row.adapter) || ui.denyWorkersAdapters.has(row.adapter)
-                ? `every ${row.adapter} channel is out together — set the adapter's reach on the rail`
-                : "a shared entry covers other channels too";
-            ui.notice = `${id} stays ${reachLabel} — ${row.reasons.join("; ")} — Space edits only this channel's own entries; ${shared}`;
-        };
-        const reach = row.reach;
-        const outAll = reach === "out-all" || reach === "out-allow";
-        let edit = "";
-        if (choice === "out-workers" && reach === "in") {
-            ui.denyWorkersModels = withEntry(ui.denyWorkersModels, id);
-            edit = `added ${id} to routing.deny.workers.models`;
-        }
-        else if (choice === "out-workers" && outAll) {
-            const found = ownFlat();
-            if (found === undefined)
-                return refuse("out");
-            takeFlat(found);
-            ui.denyWorkersModels = withEntry(ui.denyWorkersModels, found.entry);
-            edit = `moved ${found.entry} to routing.deny.workers.models`;
-        }
-        else if (choice === "out-all" && reach === "in") {
-            ui.denyModels = withEntry(ui.denyModels, id);
-            edit = `added ${id} to routing.deny.models`;
-        }
-        else if (choice === "out-all" && reach === "out-workers") {
-            // OBS-1099 review: a promotion, like a clear, takes only an entry no sibling row matches —
-            // a shared workers entry (adapter-wide or a bare id another row serves) is refused by name,
-            // never moved for its siblings and never doubled by a fresh flat deny
-            const found = ownWorkers();
-            if (found === undefined)
-                return refuse("out · workers");
-            takeFlat(found);
-            ui.denyModels = withEntry(ui.denyModels, found.entry);
-            edit = `moved ${found.entry} to routing.deny.models`;
-        }
-        else if (choice === "in" && reach !== "in") {
-            // D-205: in clears ONE row-owned reason from either the flat scopes or the workers scope —
-            // a shared flat reason (routing.deny.adapters covering every channel) never blocks clearing
-            // this row's own workers entry; the recomputed reach then names the shared reason that remains
-            const found = edits.clear ?? (outAll ? ownAllow() : undefined);
-            if (found !== undefined) {
+            else if (choice === "out-workers" && outAll) {
+                const found = ownFlat();
+                if (found === undefined)
+                    return refuse("out");
                 takeFlat(found);
-                edit = `cleared ${found.entry} from ${found.scope}`;
+                ui.denyWorkersModels = withEntry(ui.denyWorkersModels, found.entry);
+                return { edit: `moved ${found.entry} to routing.deny.workers.models` };
             }
-            else {
-                return refuse(outAll ? "out" : "out · workers");
+            else if (choice === "out-all" && reach === "in") {
+                ui.denyModels = withEntry(ui.denyModels, memberId);
+                return { edit: `added ${memberId} to routing.deny.models` };
             }
-        }
-        else {
-            ui.notice = `${id} is already ${label}`;
+            else if (choice === "out-all" && reach === "out-workers") {
+                // OBS-1099 review: a promotion, like a clear, takes only an entry no sibling row matches —
+                // a shared workers entry (adapter-wide or a bare id another row serves) is refused by name,
+                // never moved for its siblings and never doubled by a fresh flat deny
+                const found = ownWorkers();
+                if (found === undefined)
+                    return refuse("out · workers");
+                takeFlat(found);
+                ui.denyModels = withEntry(ui.denyModels, found.entry);
+                return { edit: `moved ${found.entry} to routing.deny.models` };
+            }
+            else if (choice === "in" && reach !== "in") {
+                // D-205: in clears ONE row-owned reason from either the flat scopes or the workers scope —
+                // a shared flat reason (routing.deny.adapters covering every channel) never blocks clearing
+                // this row's own workers entry; the recomputed reach then names the shared reason that remains
+                const found = edits.clear ?? (outAll ? ownAllow() : undefined);
+                if (found === undefined)
+                    return refuse(outAll ? "out" : "out · workers");
+                takeFlat(found);
+                return { edit: `cleared ${found.entry} from ${found.scope}` };
+            }
+            return { already: true };
+        });
+        const made = outcomes.flatMap((outcome) => ("edit" in outcome ? [outcome.edit] : []));
+        const refused = outcomes.flatMap((outcome) => ("refused" in outcome ? [outcome.refused] : []));
+        if (!made.length) {
+            ui.notice = refused[0] ?? `${id} is already ${label}`;
             return;
         }
-        const after = reachFor(row.adapter, row.model, row.evidence?.identity);
-        const still = reached(after.reach, choice) ? "" : ` — still out: ${after.reasons.join("; ")}`;
-        ui.lastEdit = { id, text: `space: ${edit}${still}` };
+        const after = rowReach(members);
+        const still = reached(after.reach, choice) && !after.partial ? "" : ` — still out: ${after.reasons.join("; ")}`;
+        ui.lastEdit = { id, text: `space: ${made.join("; ")}${still}` };
     };
     // OBS-1065: Enter on a greyed picker row lifts exactly its row-owned covering entry, then the
     // same picker reopens over the recomputed policy — a shared or adapter-wide entry is refused by
@@ -1588,7 +1696,13 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
                 const group = modelGroups[ui.adapterAt];
                 const suggested = rows
                     .filter((candidate) => candidate.adapter === group.adapter && !candidate.tier && candidate.suggestion !== undefined)
-                    .map((candidate) => ({ model: candidate.classifyModel ?? candidate.model, displayModel: candidate.model, suggestion: candidate.suggestion }));
+                    // T5: every real member of each suggested row stages, never only its reference id
+                    .flatMap((candidate) => membersOf(candidate.adapter, candidate).map((member) => ({
+                    model: member.model,
+                    displayModel: candidate.model,
+                    ...(member.identity !== undefined ? { identity: member.identity } : {}),
+                    suggestion: candidate.suggestion,
+                })));
                 if (!suggested.length) {
                     ui.notice = "no catalog tier suggestions among the visible unclassified models — evidence comes from the cached catalogs (AA index / API pricing)";
                     bump();
@@ -1722,6 +1836,9 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
             return "unauthed — re-probe with tickmarkr doctor (Space does not toggle reach)";
         // T10: the reasons, then where each scope is held — the overlay a reviewed w writes
         const reasons = `${row.reasons.join("; ")}${row.held.length ? ` — held: ${row.held.join("; ")}` : ""}`;
+        // T5: members disagree — never a whole-group state; each member-specific reason names its real id
+        if (row.partial)
+            return `reach: partial — ${row.reach} for some members only — ${reasons} — Space applies one choice to every member`;
         if (row.reach === "out-all")
             return `reach: out · all seats — ${reasons} — Space picks in or out · workers`;
         if (row.reach === "out-allow")
@@ -1732,7 +1849,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
             return `reach: unknown — ${reasons}`;
         return "reach: in — Space picks out · workers or out · all seats";
     };
-    const reachCell = (row) => row.reach === "in" || row.reach === "unknown" ? row.reach : `out ${row.reach === "out-workers" ? "workers" : row.reach.slice(4)}`;
+    const reachCell = (row) => row.partial ? "partial" : row.reach === "in" || row.reach === "unknown" ? row.reach : `out ${row.reach === "out-workers" ? "workers" : row.reach.slice(4)}`;
     const identityDetail = (row) => {
         if (row.evidence?.identity === undefined)
             return "";
@@ -1764,11 +1881,16 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
             `${row.adapter}:${row.model}`,
             row.tier ?? "unclassified",
             ui.efforts[row.adapter]?.[row.model] ? `effort ${ui.efforts[row.adapter][row.model]}` : "",
+            // T5: a grouped row names each member doctor recorded unauthed — up front, before the line clips
+            ...(row.evidence?.unauthed === undefined ? (row.members ?? []).filter((member) => member.unauthed !== undefined)
+                .map((member) => `${row.adapter}:${member.model} UNAUTHED — ${member.unauthed} — re-probe with tickmarkr doctor`) : []),
             ui.lastEdit?.id === `${row.adapter}:${row.model}` ? ui.lastEdit.text : "",
             identityDetail(row),
             row.tier ? reachDetail(row) : "",
             row.variants?.length ? `variants ${row.variants.join(", ")}` : "",
-            row.classifyModel ? `classify writes ${row.classifyModel}` : "",
+            // T5: a grouped row classifies (and edits) every real member; classifyModel is its reference id
+            row.members?.length ? `classify writes ${row.members.map((member) => member.model).join(", ")}`
+                : row.classifyModel ? `classify writes ${row.classifyModel}` : "",
             row.foldedModels?.length ? `${row.foldedModels.length} gateway ids folded: ${row.foldedModels.join(", ")}` : "",
             row.evidence?.unauthed !== undefined ? `UNAUTHED — ${row.evidence.unauthed}` : "",
             row.evidence?.contextWindow !== undefined ? `${fmtCtx(row.evidence.contextWindow)} ctx` : "",
@@ -1792,15 +1914,17 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         const folded = row.foldedModels?.length ?? 1;
         const name = clipPathTail(`${row.adapter}/${row.model}${folded > 1 ? ` ×${folded}` : ""}`, nameW);
         const prefixLen = Math.min(name.length, row.adapter.length + 1);
-        return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Pointer, { on: selected }), row.reach === "out-all" || row.reach === "out-allow"
-                    ? _jsx(Glyph, { kind: "off" })
-                    : row.evidence?.unauthed !== undefined || row.reach === "unknown"
-                        ? _jsx(Glyph, { kind: "fail" })
-                        : row.reach === "out-workers"
-                            ? _jsx(Glyph, { kind: "warn" })
-                            : row.tier
-                                ? _jsx(Glyph, { kind: "on" })
-                                : _jsx(Glyph, { kind: "unknown" }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: row.denied, children: [_jsx(Text, { dimColor: true, children: name.slice(0, prefixLen) }), _jsx(Text, { bold: selected, children: name.slice(prefixLen).padEnd(Math.max(nameW - prefixLen, 0)) })] }), _jsx(Text, { color: tier.color, dimColor: tier.dim, children: padCellStart(tier.text, 11) }), _jsx(Text, { dimColor: row.reach === "in", children: padCellStart(row.tier ? reachCell(row) : "", 12) }), _jsx(Text, { dimColor: true, children: padCellStart(fmtCtx(row.evidence?.contextWindow), 6) }), showPrice && _jsx(Text, { dimColor: priceCell(row) === "sub", children: padCellStart(priceCell(row), 12) }), showProbe && _jsx(Text, { dimColor: true, children: padCellStart(fmtMs(row.evidence?.probeMs), 7) })] }, `${row.adapter}:${row.model}`));
+        return (_jsxs(Text, { wrap: "truncate", children: [_jsx(Pointer, { on: selected }), row.partial
+                    ? _jsx(Glyph, { kind: "warn" })
+                    : row.reach === "out-all" || row.reach === "out-allow"
+                        ? _jsx(Glyph, { kind: "off" })
+                        : row.evidence?.unauthed !== undefined || row.reach === "unknown"
+                            ? _jsx(Glyph, { kind: "fail" })
+                            : row.reach === "out-workers"
+                                ? _jsx(Glyph, { kind: "warn" })
+                                : row.tier
+                                    ? _jsx(Glyph, { kind: "on" })
+                                    : _jsx(Glyph, { kind: "unknown" }), _jsx(Text, { children: " " }), _jsxs(Text, { dimColor: row.denied, children: [_jsx(Text, { dimColor: true, children: name.slice(0, prefixLen) }), _jsx(Text, { bold: selected, children: name.slice(prefixLen).padEnd(Math.max(nameW - prefixLen, 0)) })] }), _jsx(Text, { color: tier.color, dimColor: tier.dim, children: padCellStart(tier.text, 11) }), _jsx(Text, { dimColor: row.reach === "in", children: padCellStart(row.tier ? reachCell(row) : "", 12) }), _jsx(Text, { dimColor: true, children: padCellStart(fmtCtx(row.evidence?.contextWindow), 6) }), showPrice && _jsx(Text, { dimColor: priceCell(row) === "sub", children: padCellStart(priceCell(row), 12) }), showProbe && _jsx(Text, { dimColor: true, children: padCellStart(fmtMs(row.evidence?.probeMs), 7) })] }, `${row.adapter}:${row.model}`));
     };
     const renderPlainRow = (id, label, selected, rowW = bodyW - 2) => (_jsxs(Text, { wrap: "truncate", children: [_jsx(Pointer, { on: selected }), _jsx(Text, { bold: selected, children: clip(label, rowW) })] }, id));
     const renderShapeRow = (row, selected, rowW = bodyW - 2) => {
@@ -1846,8 +1970,8 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
         if (overlay.kind === "classify") {
             const subject = overlay.bulk
                 ? `${overlay.adapter} · ${overlay.bulk.rows.length} suggested models`
-                : overlay.displayModel
-                    ? `${overlay.adapter}:${overlay.displayModel} · writes ${overlay.model}`
+                : overlay.displayModel || classifiedMembers(overlay.adapter, overlay.model).length > 1
+                    ? `${overlay.adapter}:${overlay.displayModel ?? overlay.model} · writes ${classifiedMembers(overlay.adapter, overlay.displayModel ?? overlay.model).map((member) => member.model).join(", ")}`
                     : `${overlay.adapter}:${overlay.model}`;
             return (_jsxs(OverlayPanel, { title: `classify · ${subject}`, width: bodyW, children: [overlay.stage === "channel" && (_jsxs(_Fragment, { children: [_jsxs(Text, { dimColor: true, children: ["first touch for ", overlay.adapter, " \u2014 how is this CLI billed?"] }), _jsx(Text, { children: " " }), CHANNELS.map((channel, index) => (_jsxs(Text, { children: [_jsx(Pointer, { on: overlay.channelAt === index }), _jsx(Text, { bold: overlay.channelAt === index, children: padCell(channel, 5) }), _jsx(Text, { dimColor: true, children: channel === "sub" ? "flat-rate subscription quota" : "metered API billing" })] }, channel)))] })), overlay.stage === "tier" && (_jsxs(_Fragment, { children: [_jsx(Text, { dimColor: true, children: overlay.suggestion
                                     ? `catalog suggests ${overlay.suggestion.tier} — keep it and the provenance note arrives pre-typed`
@@ -1911,7 +2035,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
             const current = overlay.target.model === undefined
                 ? adapterReach(overlay.target.adapter)
                 : modelRows().find((row) => row.adapter === overlay.target.adapter && row.model === overlay.target.model) ?? { reach: "unknown", reasons: [] };
-            const partial = "partial" in current && current.partial;
+            const partial = "partial" in current && current.partial === true;
             // D-205: a partial rail marks no choice as selected — its channels disagree
             const on = partial || current.reach === "unknown" ? null
                 : current.reach === "out-all" || current.reach === "out-allow" ? "out-all" : current.reach;
@@ -2098,7 +2222,7 @@ export function FleetApp({ ageMs, agents, initialAllowOut = [], initialEfforts =
                 ? _jsx(Text, { color: INK.warn, children: ` ! ${clip(ui.notice, width - 4)}` })
                 : details.map((line) => _jsx(Text, { dimColor: true, children: ` ${clip(line, width - 2)}` }, line)), _jsx(KeyBar, { binds: keyBinds() })] }));
 }
-export async function runFleetInkEditor({ ageMs, adapters, health, initialAllowOut = [], initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories = [], reviewOverlay, reloadGuard, stagedRouting, holderOf, entry = "probe", initialJudge = "", judgeSeats = [], initialInput = [], input, output, debug = false, ...initialDenyProps }) {
+export async function runFleetInkEditor({ ageMs, adapters, health, initialAllowOut = [], initialEfforts, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewAdvisories = [], reviewOverlay, layerStamp, reloadGuard, stagedRouting, holderOf, entry = "probe", initialJudge = "", judgeSeats = [], initialInput = [], input, output, debug = false, ...initialDenyProps }) {
     const agents = adapters.flatMap((adapter) => {
         const state = health[adapter.id];
         if (!state?.installed)
@@ -2122,7 +2246,7 @@ export async function runFleetInkEditor({ ageMs, adapters, health, initialAllowO
     // rebuilt from output.columns/rows so a pane resize re-renders at the new size. Same root
     // element type on every rerender ⇒ React keeps the component instance, so staged edits,
     // cursor, and overlays all survive the resize.
-    const editorElement = () => (_jsx(FleetApp, { ageMs: ageMs, agents: agents, ...initialDenyProps, initialAllowOut: initialAllowOut, initialEfforts: initialEfforts, modelGroups: declaredModelGroups, initialMode: initialMode, modeOptions: modeOptions, initialMap: initialMap, modePreview: modePreview, shapeRows: shapeRows, candidatesForShape: candidatesForShape, preferOptionsForShape: preferOptionsForShape, initialSteering: initialSteering, steeringOptionsFor: steeringOptionsFor, reviewAdvisories: reviewAdvisories, reviewOverlay: reviewOverlay, reloadGuard: reloadGuard, stagedRouting: stagedRouting, holderOf: holderOf, entry: entry, initialJudge: initialJudge, judgeSeats: judgeSeats, 
+    const editorElement = () => (_jsx(FleetApp, { ageMs: ageMs, agents: agents, ...initialDenyProps, initialAllowOut: initialAllowOut, initialEfforts: initialEfforts, modelGroups: declaredModelGroups, initialMode: initialMode, modeOptions: modeOptions, initialMap: initialMap, modePreview: modePreview, shapeRows: shapeRows, candidatesForShape: candidatesForShape, preferOptionsForShape: preferOptionsForShape, initialSteering: initialSteering, steeringOptionsFor: steeringOptionsFor, reviewAdvisories: reviewAdvisories, reviewOverlay: reviewOverlay, layerStamp: layerStamp, reloadGuard: reloadGuard, stagedRouting: stagedRouting, holderOf: holderOf, entry: entry, initialJudge: initialJudge, judgeSeats: judgeSeats, 
         // v1.90.9: cap every list to the terminal minus chrome so the cursor and header can
         // never scroll off-screen (omp's 218-model list did exactly that pre-cap).
         // OBS-523: chrome is ≤12 rows worst case (header, borders, padding, scope+search,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "2.6.6",
+  "version": "2.6.8",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",