@openrig/cli 0.5.8 → 0.5.10

package/tui/dist/execution/execution-model.js

@@ -1,5 +1,5 @@
 import { detailPage, listItem, sectionRule } from "../detail.js";
-const MAX_ROWS_PER_WAVE = 5;
+import { scopeContractLines, scopeIdentityLines } from "../scopes/scopes-model.js";
 const INDETERMINATE = "INDETERMINATE";
 const RUNGS = ["locked", "built", "reviewed", "folded", "adopted"];
 /** Ordinary words for the ladder rungs. */
@@ -21,6 +21,137 @@ function clock(iso) {
 function clip(text, room) {
     return text.length > room ? `${text.slice(0, Math.max(room - 1, 0))}…` : text;
 }
+/** Keep lifecycle commands complete in the scrollable pane. Shell continuations make the
+ * visual wrap usable as one command instead of turning the hidden suffix into guesswork. */
+function shellWords(command) {
+    const words = [];
+    let word = "";
+    let quote = null;
+    let escaped = false;
+    for (const char of command) {
+        if (escaped) {
+            word += char;
+            escaped = false;
+        }
+        else if (char === "\\" && quote !== "'") {
+            word += char;
+            escaped = true;
+        }
+        else if ((char === "'" || char === '"') && (quote === null || quote === char)) {
+            word += char;
+            quote = quote === char ? null : char;
+        }
+        else if (/\s/.test(char) && quote === null) {
+            if (word)
+                words.push(word);
+            word = "";
+        }
+        else {
+            word += char;
+        }
+    }
+    if (word)
+        words.push(word);
+    return words;
+}
+function quoteShell(value) {
+    return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+/** Split only words emitted by the daemon's shellQuote helper. A continuation directly
+ * between adjacent quoted chunks is one shell argument; option-to-option continuations
+ * retain a separating space. */
+function splitQuotedWord(word, maxWidth) {
+    if (!word.startsWith("'") || !word.endsWith("'"))
+        return null;
+    const value = word.slice(1, -1).replaceAll(`'"'"'`, "'");
+    if (quoteShell(value) !== word)
+        return null;
+    const chunks = [];
+    let chunk = "";
+    for (const char of value) {
+        if (chunk && quoteShell(chunk + char).length > maxWidth) {
+            chunks.push(quoteShell(chunk));
+            chunk = char;
+        }
+        else {
+            chunk += char;
+        }
+    }
+    chunks.push(quoteShell(chunk));
+    return chunks;
+}
+function actionLines(action, width) {
+    const firstIndent = "      action ";
+    const nextIndent = "        ";
+    const room = Math.max(width, 24);
+    const parts = shellWords(action);
+    const lines = [];
+    let current = `${firstIndent}${parts.shift() ?? ""}`;
+    for (let index = 0; index < parts.length; index++) {
+        const part = parts[index];
+        const more = index < parts.length - 1;
+        if (current && `${current} ${part}${more ? " \\" : ""}`.length <= room) {
+            current += ` ${part}`;
+            continue;
+        }
+        if (current)
+            lines.push({ text: `${current} \\` });
+        const chunks = splitQuotedWord(part, room - 2);
+        if (chunks && `${nextIndent}${part}${more ? " \\" : ""}`.length > room) {
+            for (let chunkIndex = 0; chunkIndex < chunks.length - 1; chunkIndex++) {
+                lines.push({ text: `${chunks[chunkIndex]}\\` });
+            }
+            const last = chunks[chunks.length - 1];
+            if (more) {
+                lines.push({ text: `${last} \\` });
+                current = "";
+            }
+            else {
+                current = last;
+            }
+        }
+        else {
+            current = `${nextIndent}${part}`;
+        }
+    }
+    if (current)
+        lines.push({ text: current });
+    return lines;
+}
+function fitSegs(parts, width) {
+    const out = [];
+    let room = Math.max(0, width);
+    for (const part of parts) {
+        if (room <= 0)
+            break;
+        if (part.text.length <= room) {
+            out.push(part);
+            room -= part.text.length;
+            continue;
+        }
+        out.push({ ...part, text: room === 1 ? "…" : `${part.text.slice(0, room - 1)}…` });
+        room = 0;
+    }
+    return out;
+}
+function semantic(parts, width, action) {
+    const segs = fitSegs(parts, width);
+    return { text: segs.map((part) => part.text).join(""), segs, ...(action ? { action } : {}) };
+}
+function semanticAction(parts, action, width) {
+    const suffix = { text: "  (open ▸)", token: "accent", bold: true };
+    const body = fitSegs(parts, Math.max(0, width - suffix.text.length));
+    return semantic([...body, suffix], width, action);
+}
+function stateToken(word) {
+    if (word === "working" || word === "done" || word === "active")
+        return "ok";
+    if (word === "needs input" || word === "blocked" || word === "parked")
+        return "warn";
+    if (word === "failed")
+        return "error";
+    return "dim";
+}
 function open(key) {
     return { type: "execution-open", key };
 }
@@ -175,32 +306,8 @@ function waveOf(slice) {
 }
 // ---- rows ----------------------------------------------------------------------
 function sliceAction(execution, slice) {
-    return slice.scope
-        ? { type: "scopes-open", mission: execution.mission, slice: slice.scope.dirName }
-        : open(`slice:${slice.id}`);
-}
-function sliceRow(execution, slice, width, stateWidth, idWidth) {
-    // facts in priority order; a narrow pane drops from the END (proof, evidence, next…) and
-    // the assignee's decider before it ever clips a fact mid-word
-    const facts = [
-        assigneeText(slice),
-        problemText(slice),
-        slice.lane ? null : nextText(slice),
-        evidenceText(slice.cells, slice.rank),
-        proofText(slice.scope),
-    ].filter((fact) => !!fact);
-    const prefix = `${stateWord(slice).padEnd(stateWidth)}  ${slice.id.padEnd(idWidth)}  `;
-    const budget = Math.max(width - 13, 24) - prefix.length;
-    let shown = facts;
-    while (shown.join(" · ").length > budget && shown.length > 1) {
-        const decider = shown.findIndex((fact) => / \(.+\)$/.test(fact) && fact === assigneeText(slice));
-        shown = decider >= 0 ? shown.map((fact, i) => (i === decider ? fact.replace(/ \(.+\)$/, "") : fact)) : shown.slice(0, -1);
-    }
-    const factsText = shown.join(" · ");
-    const room = budget - factsText.length - 3;
-    // the name gets whatever room the facts leave; below twelve cells it is dropped, not stubbed
-    const name = room >= 12 ? `${clip(slice.name, room)} · ` : "";
-    return actionRow(`${prefix}${name}${factsText}`, sliceAction(execution, slice), width);
+    void execution;
+    return open(`slice:${slice.id}`);
 }
 function countWords(slices) {
     const counts = new Map();
@@ -209,16 +316,120 @@ function countWords(slices) {
     return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([word, n]) => `${n} ${word}`).join(", ");
 }
 function waveTitle(wave, members) {
-    return `wave ${wave} · ${members.length} slice${members.length === 1 ? "" : "s"} · ${countWords(members)}`;
+    return `WAVE ${wave} · ${members.length} slice${members.length === 1 ? "" : "s"} · ${countWords(members)}`;
+}
+function stateMark(word) {
+    if (word === "working")
+        return "●";
+    if (word === "needs input")
+        return "◐";
+    if (word === "blocked")
+        return "⚑";
+    if (word === "done")
+        return "✓";
+    if (word === "failed")
+        return "✕";
+    return "○";
+}
+function padCell(text, width) {
+    const value = clip(text, width);
+    return value + " ".repeat(Math.max(0, width - value.length));
+}
+function graphNode(slice, width) {
+    const inside = width - 2;
+    const title = ` ${slice.id} `;
+    const topTail = `${"─".repeat(Math.max(0, inside - title.length - 1))}┐`;
+    const nameText = padCell(` ${slice.name}`, inside);
+    const state = `${stateMark(stateWord(slice))} ${stateWord(slice)}`;
+    const owner = assigneeText(slice);
+    const ownerRoom = Math.max(0, inside - 1 - state.length);
+    const rawOwner = owner ? ` · ${owner}` : "";
+    const ownerText = ownerRoom > 0 ? clip(rawOwner, ownerRoom) : "";
+    const statusPad = " ".repeat(Math.max(0, inside - 1 - state.length - ownerText.length));
+    return [
+        semantic([{ text: "┌─", token: "chrome" }, { text: title, token: "accentBright", bold: true }, { text: topTail, token: "chrome" }], width),
+        semantic([{ text: "│", token: "chrome" }, { text: nameText, token: "bright" }, { text: "│", token: "chrome" }], width),
+        semantic([
+            { text: "│ ", token: "chrome" },
+            { text: state, token: stateToken(stateWord(slice)), bold: true },
+            { text: ownerText, token: "dim" },
+            { text: statusPad },
+            { text: "│", token: "chrome" },
+        ], width),
+        semantic([{ text: `└${"─".repeat(inside)}┘`, token: "chrome" }], width),
+    ];
 }
-function waveRows(execution, wave, members, width, stateWidth, idWidth, capped) {
-    const shown = capped ? members.slice(0, MAX_ROWS_PER_WAVE) : members;
-    const overflow = members.length - shown.length;
+function graphChunk(execution, members, width) {
+    const gap = 2;
+    const perRow = width >= 108 ? 3 : 2;
+    const nodeWidth = Math.min(34, Math.max(18, Math.floor((width - gap * (Math.min(perRow, members.length) - 1)) / Math.min(perRow, members.length))));
+    const out = [];
+    for (let start = 0; start < members.length; start += perRow) {
+        const chunk = members.slice(start, start + perRow);
+        const boxes = chunk.map((slice) => graphNode(slice, nodeWidth));
+        const zones = chunk.map((slice, index) => ({
+            start: index * (nodeWidth + gap),
+            end: index * (nodeWidth + gap) + nodeWidth,
+            action: sliceAction(execution, slice),
+        }));
+        for (let line = 0; line < 4; line += 1) {
+            const segs = boxes.flatMap((box, index) => [
+                ...(index > 0 ? [{ text: " ".repeat(gap) }] : []),
+                ...(box[line].segs ?? [{ text: box[line].text }]),
+            ]);
+            out.push({ text: segs.map((seg) => seg.text).join(""), segs, zones });
+        }
+        const centers = chunk.map((_, index) => index * (nodeWidth + gap) + Math.floor(nodeWidth / 2));
+        const busWidth = Math.min(width, chunk.length * nodeWidth + Math.max(0, chunk.length - 1) * gap);
+        const stubs = Array.from({ length: busWidth }, () => " ");
+        for (const center of centers)
+            if (center < stubs.length)
+                stubs[center] = "│";
+        out.push({ text: stubs.join("").trimEnd() });
+        if (chunk.length === 1) {
+            const arrow = Array.from({ length: busWidth }, () => " ");
+            if (centers[0] < arrow.length)
+                arrow[centers[0]] = "▼";
+            out.push(semantic([{ text: arrow.join("").trimEnd(), token: "chrome" }], width));
+            continue;
+        }
+        const bus = Array.from({ length: busWidth }, () => " ");
+        const lo = centers[0] ?? 0;
+        const hi = centers.at(-1) ?? lo;
+        for (let x = lo; x <= hi && x < bus.length; x += 1)
+            bus[x] = "━";
+        for (const center of centers)
+            if (center < bus.length)
+                bus[center] = "┴";
+        const mid = Math.floor((lo + hi) / 2);
+        if (mid < bus.length)
+            bus[mid] = centers.includes(mid) ? "┼" : "┬";
+        out.push(semantic([{ text: bus.join("").trimEnd(), token: "chrome" }], width));
+        const arrow = Array.from({ length: busWidth }, () => " ");
+        if (mid < arrow.length)
+            arrow[mid] = "▼";
+        out.push(semantic([{ text: arrow.join("").trimEnd(), token: "chrome" }], width));
+    }
+    return out;
+}
+function waveRows(execution, wave, members, width) {
+    const title = waveTitle(wave, members);
+    const header = semantic([
+        { text: "━ ", token: "chrome" },
+        { text: title, token: "bright", bold: true },
+        { text: ` ${"━".repeat(width)}`, token: "chrome" },
+    ], width);
+    if (width < 70)
+        return [
+            { text: "" }, header,
+            ...members.map((slice) => semanticAction([
+                { text: `${stateMark(stateWord(slice))} ${stateWord(slice).padEnd(11)}`, token: stateToken(stateWord(slice)), bold: true },
+                { text: `${slice.id}  `, token: "accentBright" },
+                { text: slice.name, token: "bright" },
+            ], sliceAction(execution, slice), width)),
+        ];
     return [
-        { text: "" },
-        sectionRule(waveTitle(wave, members), width),
-        ...shown.map((slice) => sliceRow(execution, slice, width, stateWidth, idWidth)),
-        ...(overflow > 0 ? [row(`+${overflow} more — open all ${members.length} rows in wave ${wave}`, `group:wave:${wave}`, width)] : []),
+        { text: "" }, header, ...graphChunk(execution, members, width),
     ];
 }
 function collectIndeterminate(execution, slices) {
@@ -246,20 +457,6 @@ function collectIndeterminate(execution, slices) {
     }
     return [...groups.values()].sort((a, b) => b.members.length - a.members.length);
 }
-/** The mission-level gap, stated once as two short lines (the first is the drill), or
- *  nothing when every rung is determined for every slice. */
-function evidenceGapLines(execution, slices, width) {
-    const undetermined = slices.filter((slice) => RUNGS.some((rung) => slice.cells[rung].state === "undetermined"));
-    if (undetermined.length === 0)
-        return [];
-    const gitBasis = str(record(execution.sources?.["git"])["basis"], "");
-    const noRepo = /no reachable repo|no repo/i.test(gitBasis);
-    const cause = noRepo ? "no repository reachable" : gitBasis || "evidence sources missing";
-    return [
-        row(`evidence gap — ${cause}; declared state shown`, "evidence", width),
-        { text: `    evidence unconfirmed for ${undetermined.length} of ${slices.length} slices (unknown, not waiting)` },
-    ];
-}
 function evidenceDetail(execution, slices, width) {
     const gitBasis = str(record(execution.sources?.["git"])["basis"], "(no git source cell)");
     const lines = [
@@ -284,41 +481,114 @@ function evidenceDetail(execution, slices, width) {
 // ---- overview ----------------------------------------------------------------------
 function overviewLines(execution, scopes, width) {
     const slices = sliceFacts(execution, scopes);
-    const declared = new Map();
-    for (const slice of slices)
-        declared.set(declaredText(slice), (declared.get(declaredText(slice)) ?? 0) + 1);
-    const declaredText_ = [...declared.entries()].sort((a, b) => b[1] - a[1]).map(([word, n]) => `${n} ${word}`).join(", ");
     const live = slices.filter((slice) => stateWord(slice) === "working").length;
     const problems = slices.filter((slice) => problemText(slice)).length;
     const build = shortSha(record(execution.sources?.["build_info"])["commit"]);
-    const lines = [
-        { text: `  ${execution.mission} EXECUTION · ${slices.length} slice${slices.length === 1 ? "" : "s"}` },
-        { text: `  declared in slice files: ${declaredText_ || "none"} · live now: ${live} working${problems ? `, ${problems} with a problem` : ""}` },
-        row(`sources · derived ${clock(execution.derived_at) || "?"} · daemon build ${build}`, "sources", width),
-        ...evidenceGapLines(execution, slices, width),
+    const now = slices.filter((slice) => stateWord(slice) === "working").map((slice) => slice.id);
+    const needsHuman = slices.filter((slice) => problemText(slice));
+    const done = slices.filter((slice) => declaredText(slice) === "done").length;
+    const next = slices.find((slice) => nextText(slice) === "ready to start");
+    const unknown = slices.filter((slice) => RUNGS.some((rung) => slice.cells[rung].state === "undetermined")).length;
+    const missionState = problems > 0 ? "NEEDS ATTENTION" : live > 0 ? "ACTIVE" : done === slices.length && slices.length > 0 ? "COMPLETE" : "QUIET";
+    const missionToken = problems > 0 ? "warn" : live > 0 || missionState === "COMPLETE" ? "ok" : "dim";
+    const nowText = now.length ? now.join(", ") : "no live slice";
+    const nextValue = next ? `${next.id} · ready to start` : "no sequenced next transition";
+    const progress = `${done}/${slices.length} declared done · ${live} working${problems ? ` · ${problems} with a problem` : ""}`;
+    const fact = (label, value, token) => semantic([
+        { text: `  ${label.padEnd(10)}`, token: "dim", bold: true },
+        { text: value, token },
+    ], width);
+    const narrowFact = (label, value, token) => [
+        semantic([{ text: `  ${label}`, token: "dim", bold: true }], width),
+        semantic([{ text: `    ${value}`, token }], width),
     ];
+    const lines = [semantic([
+            { text: execution.mission, token: "accentBright", bold: true },
+            { text: " · ", token: "chrome" },
+            { text: missionState, token: missionToken, bold: true },
+            { text: " · ", token: "chrome" },
+            { text: `${slices.length} slice${slices.length === 1 ? "" : "s"}`, token: "bright" },
+        ], width)];
+    if (width < 70) {
+        lines.push(...narrowFact("NOW", nowText, now.length ? "ok" : "dim"));
+        lines.push(...narrowFact("NEXT", nextValue, next ? "accentBright" : "dim"));
+        lines.push(...narrowFact("PROGRESS", progress, "bright"));
+    }
+    else {
+        lines.push(fact("NOW", nowText, now.length ? "ok" : "dim"));
+        lines.push(fact("NEXT", nextValue, next ? "accentBright" : "dim"));
+        lines.push(fact("PROGRESS", progress, "bright"));
+    }
+    if (needsHuman.length) {
+        const first = needsHuman[0];
+        lines.push(semanticAction([
+            { text: "  ⚑ NEEDS HUMAN ", token: "warn", bold: true },
+            { text: `${needsHuman.map((slice) => slice.id).join(", ")} · ${problemText(first)}`, token: "bright" },
+        ], sliceAction(execution, first), width));
+    }
+    const provenanceAction = unknown > 0 ? open("evidence") : open("sources");
+    const provenance = width < 70 && unknown > 0
+        ? [{ text: "  provenance · ", token: "dim" }, { text: `evidence gap ${unknown}/${slices.length}`, token: "warn" }]
+        : [
+            { text: "  provenance ", token: "dim" },
+            { text: "·", token: "chrome" },
+            { text: ` ${clock(execution.derived_at) || "?"} · build ${build}`, token: "dim" },
+            ...(unknown > 0 ? [
+                { text: " · ", token: "chrome" },
+                { text: `evidence gap ${unknown}/${slices.length} unknown`, token: "warn" },
+            ] : []),
+        ];
+    lines.push(semanticAction(provenance, provenanceAction, width));
+    lines.push(...lifecycleLines(execution, width));
     const waves = new Map();
     for (const slice of slices)
         waves.set(waveOf(slice), [...(waves.get(waveOf(slice)) ?? []), slice]);
-    const stateWidth = Math.max(...slices.map((slice) => stateWord(slice).length), 4);
-    const idWidth = Math.max(...slices.map((slice) => slice.id.length), 1);
     for (const [wave, members] of waves)
-        lines.push(...waveRows(execution, wave, members, width, stateWidth, idWidth, true));
+        lines.push(...waveRows(execution, wave, members, width));
     if (slices.length === 0)
         lines.push({ text: "  (no slices on this mission)" });
     return lines;
 }
+function lifecycleLines(execution, width) {
+    const instances = execution.lifecycle_instances ?? [];
+    if (instances.length === 0)
+        return [];
+    const lines = [{ text: "" }, sectionRule(`LIFECYCLE · ${instances.length} instance${instances.length === 1 ? "" : "s"}`, width)];
+    for (const raw of instances) {
+        const instance = record(raw);
+        const instanceId = str(instance["instance_id"], INDETERMINATE);
+        lines.push({ text: `  ${instanceId} · ${str(instance["status"], INDETERMINATE)} · key ${str(instance["operation_key"], INDETERMINATE)}` });
+        const packets = Array.isArray(instance["frontier_packets"]) ? instance["frontier_packets"] : [];
+        for (const rawPacket of packets) {
+            const packet = record(rawPacket);
+            lines.push({ text: clip(`    ▸ ${str(packet["step_id"], INDETERMINATE)} · ${str(packet["owner"], INDETERMINATE)} · ${str(packet["queue_state"], INDETERMINATE)} · packet ${str(packet["packet_id"], INDETERMINATE)}`, width) });
+            if (packet["blocked_on"])
+                lines.push({ text: clip(`      blocked on ${str(packet["blocked_on"])}`, width) });
+            lines.push(...actionLines(str(packet["targeted_action"], INDETERMINATE), width));
+        }
+        const failures = Array.isArray(instance["failure_occurrences"]) ? instance["failure_occurrences"] : [];
+        for (const rawFailure of failures) {
+            const failure = record(rawFailure);
+            if (failure["status"] !== "unresolved")
+                continue;
+            lines.push({ text: clip(`    ▲ ${str(failure["step_id"], INDETERMINATE)} · occurrence ${str(failure["occurrence_id"], INDETERMINATE)}${failure["failure_reason"] ? ` · ${str(failure["failure_reason"])}` : ""}`, width) });
+            lines.push(...actionLines(str(failure["targeted_action"], INDETERMINATE), width));
+        }
+        const unknowns = Array.isArray(instance["unknowns"]) ? instance["unknowns"] : [];
+        for (const unknown of unknowns)
+            lines.push({ text: clip(`    ? ${str(unknown, INDETERMINATE)}`, width) });
+    }
+    return lines;
+}
 function waveDetail(execution, scopes, width, key) {
     const wave = key.slice("group:wave:".length);
     const slices = sliceFacts(execution, scopes);
     const members = slices.filter((slice) => waveOf(slice) === wave);
     if (members.length === 0)
         return null;
-    const stateWidth = Math.max(...members.map((slice) => stateWord(slice).length), 4);
-    const idWidth = Math.max(...members.map((slice) => slice.id.length), 1);
     return [
         { text: `${execution.mission} · wave ${wave} · all ${members.length} rows` },
-        ...waveRows(execution, wave, members, width, stateWidth, idWidth, false),
+        ...waveRows(execution, wave, members, width),
         { text: "" },
         back(),
     ];
@@ -330,70 +600,163 @@ function back() {
 function laneKey(lane) {
     return `lane:${str(lane["qitem_id"], "unknown")}`;
 }
-function sliceDetail(execution, slices, id) {
-    const slice = slices.find((item) => item.id === id);
+function card(title, rows, width) {
+    const w = Math.max(28, width);
+    const label = ` ${title} `;
+    const top = `┌─${label}${"─".repeat(Math.max(0, w - label.length - 3))}┐`;
+    return [
+        { text: clip(top, w) },
+        ...rows.map((item) => {
+            const suffix = item.action ? "  (open ▸)" : "";
+            const value = clip(item.text.trim(), Math.max(1, w - 4 - suffix.length));
+            return { ...item, text: `│ ${padCell(value + suffix, w - 4)} │` };
+        }),
+        { text: `└${"─".repeat(w - 2)}┘` },
+    ];
+}
+function cardField(label, value, action) {
+    return { text: `${`${label}:`.padEnd(13)} ${value}`, ...(action ? { action } : {}) };
+}
+function wrapWords(text, width) {
+    const room = Math.max(1, width);
+    const out = [];
+    let line = "";
+    for (const raw of text.split(/\s+/).filter(Boolean)) {
+        let word = raw;
+        while (word.length > room) {
+            if (line) {
+                out.push(line);
+                line = "";
+            }
+            out.push(word.slice(0, room));
+            word = word.slice(room);
+        }
+        if (!word)
+            continue;
+        if (!line)
+            line = word;
+        else if (line.length + word.length + 1 <= room)
+            line += ` ${word}`;
+        else {
+            out.push(line);
+            line = word;
+        }
+    }
+    if (line)
+        out.push(line);
+    return out.length ? out : [""];
+}
+function wrappedCardField(label, value, width) {
+    const prefix = `${`${label}:`.padEnd(13)} `;
+    const continuation = " ".repeat(prefix.length);
+    const firstRoom = Math.max(8, width - 4 - prefix.length);
+    const chunks = wrapWords(value, firstRoom);
+    return chunks.map((chunk, index) => ({ text: `${index === 0 ? prefix : continuation}${chunk}` }));
+}
+function touchedRows(detail, width) {
+    if (!detail)
+        return [cardField("served data", "slice detail not loaded for this selection")];
+    const latest = new Map();
+    for (const event of detail.story.events)
+        if (event.actorSession)
+            latest.set(event.actorSession, event);
+    if (latest.size === 0)
+        return [cardField("actors", "none in the served slice event history")];
+    const limit = width < 70 ? 1 : 3;
+    const shown = [...latest.entries()].sort((a, b) => b[1].ts.localeCompare(a[1].ts)).slice(0, limit);
+    return [
+        ...shown.flatMap(([actor, event]) => [
+            ...wrappedCardField("actor", actor, width),
+            ...wrappedCardField("last change", `${clock(event.ts) || event.ts} · ${event.kind}${event.qitemId ? ` · ${event.qitemId}` : ""}`, width),
+        ]),
+        cardField("history", `${latest.size} served actor${latest.size === 1 ? "" : "s"} · latest ${shown.length} shown`),
+    ];
+}
+function rulingRows(detail, width) {
+    if (!detail)
+        return [cardField("served data", "slice detail not loaded for this selection")];
+    const latest = [...detail.decisions.rows].sort((a, b) => b.ts.localeCompare(a.ts))[0];
+    if (!latest)
+        return [cardField("decision", "none in the served slice decision history")];
+    return [
+        ...wrappedCardField("actor", `${latest.actor} · ${clock(latest.ts) || latest.ts} · ${latest.verb}`, width),
+        ...wrappedCardField("qitem", latest.qitemId, width),
+        ...wrappedCardField("decision", latest.reason ?? "no decision reason served", width),
+        cardField("history", `${detail.decisions.rows.length} served decision${detail.decisions.rows.length === 1 ? "" : "s"} · latest shown`),
+    ];
+}
+function sliceDetail(execution, slices, id, width, richDetail, scopeOpts = { collapseReqs: false, narrative: false }) {
+    const slice = slices.find((item) => item.id === id || item.dir === id);
     if (!slice)
         return null;
-    const sections = [];
-    const ladderLines = [];
+    const detail = richDetail?.name === slice.dir ? richDetail : null;
+    const activity = record(slice.lane?.["activity"]);
+    const needs = problemText(slice);
+    const deps = Array.isArray(slice.sequencing?.["depends_on"]) ? slice.sequencing["depends_on"].map(String) : [];
+    const unlocks = slices.filter((candidate) => {
+        const candidateDeps = candidate.sequencing?.["depends_on"];
+        return Array.isArray(candidateDeps) && candidateDeps.map(String).includes(slice.id);
+    }).map((candidate) => candidate.id);
+    const ownership = [
+        cardField("seat", slice.lane ? str(slice.lane["seat"]) : "none — no claimed lane", slice.lane ? open(laneKey(slice.lane)) : undefined),
+        cardField("activity", slice.lane ? str(activity["activity"], INDETERMINATE) : "not assigned"),
+        cardField("decided by", slice.lane ? str(activity["decided_by"] ?? activity["basis"], "basis unavailable") : "—"),
+        cardField("changed", slice.lane ? str(activity["changed_at"], "—") : "—"),
+    ];
+    const evidence = [];
     for (const rung of RUNGS) {
         const cell = slice.cells[rung];
         const value = rung === "built" ? (cell.state === "yes" ? shortSha(cell.value) : "undetermined") : cell.state;
-        ladderLines.push({ text: `  ${RUNG_WORD[rung].padEnd(12)} ${value}` });
-        ladderLines.push({ text: `               basis: ${cell.basis}` });
+        evidence.push(cardField(RUNG_WORD[rung], `${value} · ${cell.basis}`));
     }
     const legs = record(slice.ladder["reviewed"])["legs"];
     if (Array.isArray(legs))
         for (const leg of legs) {
             const l = record(leg);
-            ladderLines.push(listItem(`review leg ${str(l["verdict"], "?")} · ${str(l["artifact_type"], "?")} · ${str(l["path"])}`, undefined, 12));
+            evidence.push(cardField("review leg", `${str(l["verdict"], "?")} · ${str(l["artifact_type"], "?")} · ${str(l["path"])}`));
         }
-    sections.push({
-        title: `declared ${declaredText(slice)} · evidence ${evidenceText(slice.cells, slice.rank)}`,
-        lines: ladderLines,
-    });
-    const seq = slice.sequencing;
-    if (seq) {
-        const deps = Array.isArray(seq["depends_on"]) ? seq["depends_on"].map(String) : [];
-        const blocked = blockerText(seq["blocked_on_rows"]);
-        sections.push({
-            title: "sequencing",
-            fields: [
-                { label: "depends on", value: deps.join(", ") || "(none)" },
-                { label: "next up", value: `${str(seq["next_up"], INDETERMINATE)} — ${str(seq["next_up_basis"], "no basis given")}` },
-                { label: "rank", value: str(seq["next_up_rank"], "—") },
-                { label: "blocked on", value: blocked || "(no rows)" },
-                { label: "wave", value: waveOf(slice) },
-            ],
-        });
-    }
-    if (slice.scope) {
-        const drops = slice.scope.proofContract.flatMap((contract) => contract.drops.map((drop) => `${drop.artifactType ?? "?"} ${drop.verdict ?? ""} · ${drop.file}`));
-        sections.push({
-            title: `proof ${slice.scope.proof.paired} of ${slice.scope.proof.total} paired`,
-            lines: drops.length ? drops.map((drop) => listItem(drop)) : [{ text: "  (no proof drops recorded)" }],
-        });
-    }
-    if (slice.lane) {
-        const activity = record(slice.lane["activity"]);
-        sections.push({
-            title: "lane",
-            fields: [
-                { label: "seat", value: str(slice.lane["seat"]) },
-                { label: "activity", value: `${str(activity["activity"], INDETERMINATE)} · by ${str(activity["decided_by"], "?")} ${clock(activity["changed_at"])}`.trim(), link: open(laneKey(slice.lane)) },
-            ],
-        });
-    }
-    const source = record(seq?.["source"]);
-    sections.push({
-        title: "sources",
-        fields: [
-            { label: "spec", value: str(source["spec_path"], "(not named)") },
-            { label: "arrangement", value: str(source["arrangement_path"], "(not named)") },
-            { label: "wave map", value: str(source["wave_map_row"], "(not named)") },
-        ],
-    });
-    return [...detailPage({ text: `${slice.id} — ${slice.name}` }, sections), { text: "" }, back()];
+    const typedRows = slice.lane ? [
+        cardField("qitem", str(slice.lane["qitem_id"]), open(laneKey(slice.lane))),
+        cardField("pickup", str(record(slice.lane["pickup"])["state"], str(slice.park?.["pickup_state"], INDETERMINATE))),
+        cardField("needs input", Number(record(activity["needs_input"])["count"] ?? 0) > 0 ? str(record(activity["needs_input"])["reason"], "input") : "none"),
+        cardField("repo join", `${str(slice.lane["worktree_path"], INDETERMINATE)} · ${str(slice.lane["branch"], INDETERMINATE)}`),
+    ] : [cardField("rows", "none — no typed queue row for this slice")];
+    if (slice.park)
+        typedRows.push(cardField("park", `${str(slice.park["pickup_state"], INDETERMINATE)} · wake ${str(slice.park["wake_target"], "none armed")}`));
+    const dependencies = [
+        cardField("wave", waveOf(slice)),
+        cardField("depends on", deps.join(", ") || "none"),
+        cardField("unlocks", unlocks.join(", ") || "none"),
+        cardField("next", nextText(slice) ?? "no next transition derived"),
+        cardField("blocked on", blockerText(slice.sequencing?.["blocked_on_rows"]) || "none"),
+    ];
+    const source = record(slice.sequencing?.["source"]);
+    const sourceRows = [
+        cardField("spec", str(source["spec_path"], "not named")),
+        cardField("arrangement", str(source["arrangement_path"], "not named")),
+        cardField("wave map", str(source["wave_map_row"], "not named")),
+    ];
+    const identity = slice.scope
+        ? scopeIdentityLines(slice.scope, execution.mission, width)
+        : [
+            { text: clip(`${slice.id} · ${slice.name} · ${stateMark(stateWord(slice))} ${stateWord(slice)} · wave ${waveOf(slice)}`, width) },
+        ];
+    const authored = slice.scope
+        ? scopeContractLines(slice.scope, { ...scopeOpts, width })
+        : [{ text: "" }, ...card("AUTHORED CONTRACT", [cardField("state", "scope detail not served")], width)];
+    return [
+        ...identity,
+        { text: "" }, ...card("OWNERSHIP", ownership, width),
+        { text: "" }, ...card("TOUCHED", touchedRows(detail, width), width),
+        { text: "" }, ...card(`EVIDENCE · declared ${declaredText(slice)} · ${evidenceText(slice.cells, slice.rank)}`, evidence, width),
+        { text: "" }, ...card("RULING", rulingRows(detail, width), width),
+        { text: "" }, ...card("NEEDS YOU", [cardField("state", needs ?? "none on current projection")], width),
+        { text: "" }, ...card("TYPED ROWS", typedRows, width),
+        { text: "" }, ...card("DEPENDENCIES", dependencies, width),
+        ...authored,
+        { text: "" }, ...card("SOURCES", sourceRows, width),
+        { text: "" }, back(),
+    ];
 }
 function laneDetail(execution, key) {
     const lane = (execution.q1_lanes ?? []).find((item) => laneKey(item) === key);
@@ -460,7 +823,7 @@ function sourcesDetail(execution) {
     lines.push(back());
     return lines;
 }
-export function executionContentLines(execution, scopes, readErrors, opened, width = 96, pending = false) {
+export function executionContentLines(execution, scopes, readErrors, opened, width = 96, pending = false, sliceDetailRead, scopeOpts = { collapseReqs: false, narrative: false }) {
     if (!execution) {
         const failure = readErrors.find((entry) => entry.startsWith("execution:"));
         // three different truths, never one message: the read failed (named), the read has
@@ -480,7 +843,7 @@ export function executionContentLines(execution, scopes, readErrors, opened, wid
                 : opened.startsWith("group:wave:")
                     ? waveDetail(execution, scopes, width, opened)
                     : opened.startsWith("slice:")
-                        ? sliceDetail(execution, slices, opened.slice("slice:".length))
+                        ? sliceDetail(execution, slices, opened.slice("slice:".length), width, sliceDetailRead, scopeOpts)
                         : opened.startsWith("lane:") || opened.startsWith("park:")
                             ? laneDetail(execution, opened)
                             : null;