@openrig/cli 0.5.10 → 0.5.12

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

@@ -1,5 +1,7 @@
-import { detailPage, listItem, sectionRule } from "../detail.js";
-import { scopeContractLines, scopeIdentityLines } from "../scopes/scopes-model.js";
+import { DEFAULT_TIME_ZONE, displayTime } from "../time.js";
+import { workflowOverview, workflowDetail } from "./workflow-model.js";
+import { wrapDetailLines, detailPage, listItem, sectionRule } from "../detail.js";
+import { scopeContractLines, scopeIdentityLines, proofProvenanceLines } from "../scopes/scopes-model.js";
 const INDETERMINATE = "INDETERMINATE";
 const RUNGS = ["locked", "built", "reviewed", "folded", "adopted"];
 /** Ordinary words for the ladder rungs. */
@@ -15,109 +17,9 @@ function str(value, fallback = "?") {
 function shortSha(value) {
     return typeof value === "string" ? value.slice(0, 9) : "?";
 }
-function clock(iso) {
-    return typeof iso === "string" && iso.length >= 19 ? `${iso.slice(11, 19)}Z` : "";
-}
 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);
@@ -211,6 +113,7 @@ function sliceFacts(execution, scopes) {
             name: sliceName(scope, dir),
             order: seqIndex >= 0 ? seqIndex : seq.length + index,
             ladder,
+            readiness: execution.readiness?.slices.find(s => s.scope === dir)?.readiness ?? null,
             cells,
             rank: reachedRank(cells),
             sequencing: seqIndex >= 0 ? seq[seqIndex] : null,
@@ -412,7 +315,19 @@ function graphChunk(execution, members, width) {
     }
     return out;
 }
-function waveRows(execution, wave, members, width) {
+function planningLines(execution, width, wave, expanded = false) {
+    const guidance = (execution.planning_guidance ?? []).filter(item => item.wave === wave &&
+        (expanded || (wave ? item.label !== "Review" : item.label === "Integration decision")));
+    if (!guidance.length)
+        return [];
+    return wrapDetailLines([
+        sectionRule(`Authored guidance${wave ? " · " + wave : " · mission"}`, width),
+        { text: "  Admission guides decisions. Executable dependencies, proof and custody are separate facts." },
+        ...guidance.map(item => ({ text: `  ${item.label}: ${item.text}` })),
+        { text: `  Source: ${guidance[0].source.split("#")[0]} · arrangement${wave ? ".waves" : ""}` },
+    ], width);
+}
+function waveRows(execution, wave, members, width, expanded = false) {
     const title = waveTitle(wave, members);
     const header = semantic([
         { text: "━ ", token: "chrome" },
@@ -422,6 +337,7 @@ function waveRows(execution, wave, members, width) {
     if (width < 70)
         return [
             { text: "" }, header,
+            ...planningLines(execution, width, wave, expanded),
             ...members.map((slice) => semanticAction([
                 { text: `${stateMark(stateWord(slice))} ${stateWord(slice).padEnd(11)}`, token: stateToken(stateWord(slice)), bold: true },
                 { text: `${slice.id}  `, token: "accentBright" },
@@ -429,7 +345,7 @@ function waveRows(execution, wave, members, width) {
             ], sliceAction(execution, slice), width)),
         ];
     return [
-        { text: "" }, header, ...graphChunk(execution, members, width),
+        { text: "" }, header, ...planningLines(execution, width, wave, expanded), ...graphChunk(execution, members, width),
     ];
 }
 function collectIndeterminate(execution, slices) {
@@ -446,6 +362,8 @@ function collectIndeterminate(execution, slices) {
     // Only the FIRST undetermined rung is a blind spot; every rung above it is undetermined
     // as a consequence and would repeat the same fact.
     for (const slice of slices) {
+        if (slice.readiness?.configured && slice.cells.built.state !== "yes")
+            continue;
         const first = RUNGS.find((rung) => slice.cells[rung].state === "undetermined");
         if (first)
             add(RUNG_WORD[first], slice.id, slice.cells[first].basis);
@@ -457,18 +375,22 @@ function collectIndeterminate(execution, slices) {
     }
     return [...groups.values()].sort((a, b) => b.members.length - a.members.length);
 }
-function evidenceDetail(execution, slices, width) {
+function evidenceDetail(execution, slices, width, timeZone = DEFAULT_TIME_ZONE) {
+    const attributed = slices.filter(slice => slice.readiness?.configured);
     const gitBasis = str(record(execution.sources?.["git"])["basis"], "(no git source cell)");
     const lines = [
-        { text: `${execution.mission} · evidence gap · derived ${clock(execution.derived_at) || "?"}` },
+        { text: `${execution.mission} · ${attributed.length ? "proof provenance" : "evidence gap"} · derived ${displayTime(execution.derived_at, timeZone) || "?"}` },
         { text: "" },
-        { text: "  Declared state comes from each slice file. Evidence rungs come from the daemon's" },
-        { text: "  execution projection, which needs a reachable repository to confirm reviewed, merged" },
-        { text: "  and live. Unconfirmed is not waiting work and not done; it is unknown." },
-        { text: "" },
-        sectionRule("repository source", width),
-        { text: `  git:         ${gitBasis}` },
     ];
+    if (attributed.length) {
+        lines.push(...wrapDetailLines([{ text: "  Mission proof revision: " + execution.readiness.revision }], width));
+        for (const slice of attributed)
+            lines.push({ text: "" }, listItem(slice.id + " · " + slice.name, open(`slice:${slice.id}`)), ...proofProvenanceLines(slice.readiness, width));
+    }
+    else {
+        lines.push(...wrapDetailLines([{ text: "  Declared state comes from each slice file. Legacy code evidence uses candidate tags, review records and Git. Unconfirmed is unknown; it does not establish waiting work or completion." }], width));
+    }
+    lines.push({ text: "" }, sectionRule("code lineage · separate from item judgments", width), { text: `  git:         ${gitBasis}` }, ...wrapDetailLines([{ text: "  Build, review, merge and live-runtime facts remain on each slice's code evidence. Artifact acceptance supplies none of these code facts." }], width));
     for (const item of collectIndeterminate(execution, slices)) {
         lines.push({ text: "" }, sectionRule(`${item.where} unconfirmed for ${item.members.length} slice${item.members.length === 1 ? "" : "s"}`, width));
         lines.push({ text: `  basis:       ${item.basis}` });
@@ -479,21 +401,22 @@ function evidenceDetail(execution, slices, width) {
     return lines;
 }
 // ---- overview ----------------------------------------------------------------------
-function overviewLines(execution, scopes, width) {
+function overviewLines(execution, scopes, width, timeZone = DEFAULT_TIME_ZONE) {
     const slices = sliceFacts(execution, scopes);
     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 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 attributed = execution.readiness?.slices.some(s => s.readiness.configured) === true;
+    const done = attributed ? execution.readiness.slices.filter(s => s.readiness.state === "ready").length : 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 unknown = slices.filter((slice) => !slice.readiness?.configured && RUNGS.some((rung) => slice.cells[rung].state === "undetermined")).length;
+    const missionState = attributed ? `PROOF ${execution.readiness.state.toUpperCase()}` : 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 progress = `${done}/${slices.length} ${attributed ? "proof ready" : "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 },
@@ -505,7 +428,7 @@ function overviewLines(execution, scopes, width) {
     const lines = [semantic([
             { text: execution.mission, token: "accentBright", bold: true },
             { text: " · ", token: "chrome" },
-            { text: missionState, token: missionToken, bold: true },
+            { text: execution.lifecycle_instances?.length ? `Slices: ${missionState}` : missionState, token: missionToken, bold: true },
             { text: " · ", token: "chrome" },
             { text: `${slices.length} slice${slices.length === 1 ? "" : "s"}`, token: "bright" },
         ], width)];
@@ -526,20 +449,22 @@ function overviewLines(execution, scopes, width) {
             { 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));
+    const provenanceAction = attributed || unknown > 0 ? open("evidence") : open("sources");
+    const provenance = [
+        { text: "  provenance · ", token: "dim" },
+        { text: attributed ? `proof judgments · ${done}/${slices.length} ready${unknown ? ` · ${unknown} legacy unknown` : ""}` : unknown > 0 ? `evidence gap ${unknown}/${slices.length} unknown` : `build ${build}`, token: unknown > 0 || (attributed && execution.readiness.state === "unknown") ? "warn" : "dim" },
+    ];
+    const localTime = displayTime(execution.derived_at, timeZone);
+    if (provenance.reduce((n, s) => n + s.text.length, 0) + localTime.length + 3 <= width) {
+        provenance.push({ text: ` · ${localTime}`, token: "dim" });
+        lines.push(semanticAction(provenance, provenanceAction, width));
+    }
+    else {
+        lines.push(semanticAction(provenance, provenanceAction, width));
+        lines.push(...wrapDetailLines([{ text: `  derived ${localTime}` }], width));
+    }
     lines.push(...lifecycleLines(execution, width));
+    lines.push(...planningLines(execution, width));
     const waves = new Map();
     for (const slice of slices)
         waves.set(waveOf(slice), [...(waves.get(waveOf(slice)) ?? []), slice]);
@@ -549,37 +474,7 @@ function overviewLines(execution, scopes, width) {
         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;
-}
+const lifecycleLines = workflowOverview;
 function waveDetail(execution, scopes, width, key) {
     const wave = key.slice("group:wave:".length);
     const slices = sliceFacts(execution, scopes);
@@ -588,7 +483,8 @@ function waveDetail(execution, scopes, width, key) {
         return null;
     return [
         { text: `${execution.mission} · wave ${wave} · all ${members.length} rows` },
-        ...waveRows(execution, wave, members, width),
+        ...planningLines(execution, width),
+        ...waveRows(execution, wave, members, width, true),
         { text: "" },
         back(),
     ];
@@ -653,7 +549,7 @@ function wrappedCardField(label, value, width) {
     const chunks = wrapWords(value, firstRoom);
     return chunks.map((chunk, index) => ({ text: `${index === 0 ? prefix : continuation}${chunk}` }));
 }
-function touchedRows(detail, width) {
+function touchedRows(detail, width, timeZone = DEFAULT_TIME_ZONE) {
     if (!detail)
         return [cardField("served data", "slice detail not loaded for this selection")];
     const latest = new Map();
@@ -667,25 +563,25 @@ function touchedRows(detail, width) {
     return [
         ...shown.flatMap(([actor, event]) => [
             ...wrappedCardField("actor", actor, width),
-            ...wrappedCardField("last change", `${clock(event.ts) || event.ts} · ${event.kind}${event.qitemId ? ` · ${event.qitemId}` : ""}`, width),
+            ...wrappedCardField("last change", `${displayTime(event.ts, timeZone) || 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) {
+function rulingRows(detail, width, timeZone = DEFAULT_TIME_ZONE) {
     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("actor", `${latest.actor} · ${displayTime(latest.ts, timeZone) || 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 }) {
+function sliceDetail(execution, slices, id, width, richDetail, scopeOpts = { collapseReqs: false, narrative: false }, timeZone = DEFAULT_TIME_ZONE) {
     const slice = slices.find((item) => item.id === id || item.dir === id);
     if (!slice)
         return null;
@@ -747,11 +643,13 @@ function sliceDetail(execution, slices, id, width, richDetail, scopeOpts = { col
     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("TOUCHED", touchedRows(detail, width, timeZone), width),
+        { text: "" }, ...proofProvenanceLines(slice.readiness, width),
+        { text: "" }, ...card(`${slice.readiness?.configured ? "CODE LINEAGE" : "EVIDENCE"} · declared ${declaredText(slice)} · ${evidenceText(slice.cells, slice.rank)}`, evidence, width),
+        { text: "" }, ...card("RULING", rulingRows(detail, width, timeZone), width),
         { text: "" }, ...card("NEEDS YOU", [cardField("state", needs ?? "none on current projection")], width),
         { text: "" }, ...card("TYPED ROWS", typedRows, width),
+        { text: "" }, ...planningLines(execution, width), ...planningLines(execution, width, waveOf(slice), true),
         { text: "" }, ...card("DEPENDENCIES", dependencies, width),
         ...authored,
         { text: "" }, ...card("SOURCES", sourceRows, width),
@@ -808,8 +706,8 @@ function laneDetail(execution, key) {
     const heading = lane ? `lane ${str(lane["slice"])} · ${str(lane["seat"])}` : `row ${str(park?.["qitem_id"])}`;
     return [...detailPage({ text: heading }, sections), { text: "" }, back()];
 }
-function sourcesDetail(execution) {
-    const lines = [{ text: `sources behind ${execution.mission} · derived ${clock(execution.derived_at) || "?"}` }];
+function sourcesDetail(execution, timeZone = DEFAULT_TIME_ZONE, width = 96) {
+    const lines = [{ text: `sources behind ${execution.mission} · derived ${displayTime(execution.derived_at, timeZone) || "?"}` }];
     for (const [name, raw] of Object.entries(execution.sources ?? {})) {
         const cell = record(raw);
         lines.push({ text: "" });
@@ -820,10 +718,11 @@ function sourcesDetail(execution) {
             lines.push({ text: `  ${str(raw, "—")}` });
     }
     lines.push({ text: "" });
+    lines.push(...planningLines(execution, width, undefined, true));
     lines.push(back());
     return lines;
 }
-export function executionContentLines(execution, scopes, readErrors, opened, width = 96, pending = false, sliceDetailRead, scopeOpts = { collapseReqs: false, narrative: false }) {
+export function executionContentLines(execution, scopes, readErrors, opened, width = 96, pending = false, sliceDetailRead, scopeOpts = { collapseReqs: false, narrative: false }, timeZone = DEFAULT_TIME_ZONE) {
     if (!execution) {
         const failure = readErrors.find((entry) => entry.startsWith("execution:"));
         // three different truths, never one message: the read failed (named), the read has
@@ -836,20 +735,22 @@ export function executionContentLines(execution, scopes, readErrors, opened, wid
     }
     if (opened) {
         const slices = sliceFacts(execution, scopes);
-        const page = opened === "sources"
-            ? sourcesDetail(execution)
-            : opened === "evidence"
-                ? evidenceDetail(execution, slices, width)
-                : opened.startsWith("group:wave:")
-                    ? waveDetail(execution, scopes, width, opened)
-                    : opened.startsWith("slice:")
-                        ? sliceDetail(execution, slices, opened.slice("slice:".length), width, sliceDetailRead, scopeOpts)
-                        : opened.startsWith("lane:") || opened.startsWith("park:")
-                            ? laneDetail(execution, opened)
-                            : null;
+        const page = opened.startsWith("workflow:") || opened.startsWith("packet:")
+            ? workflowDetail(execution, opened, width, timeZone)
+            : opened === "sources"
+                ? sourcesDetail(execution, timeZone, width)
+                : opened === "evidence"
+                    ? evidenceDetail(execution, slices, width, timeZone)
+                    : opened.startsWith("group:wave:")
+                        ? waveDetail(execution, scopes, width, opened)
+                        : opened.startsWith("slice:")
+                            ? sliceDetail(execution, slices, opened.slice("slice:".length), width, sliceDetailRead, scopeOpts, timeZone)
+                            : opened.startsWith("lane:") || opened.startsWith("park:")
+                                ? laneDetail(execution, opened)
+                                : null;
         return page ?? [{ text: `  ${opened} is not in the current snapshot (it may have closed or been re-derived)` }, { text: "" }, back()];
     }
-    return overviewLines(execution, scopes, width);
+    return overviewLines(execution, scopes, width, timeZone);
 }
 /** Compact source-grounded execution strip embedded in the existing rich SCOPES
  * slice detail. Missing projection/slice data stays explicit instead of being inferred. */
@@ -871,11 +772,13 @@ export function executionSliceStripLines(execution, sliceId, sliceDir, width = 9
     return [
         { text: "" },
         sectionRule(`EXECUTION · ${problem ? stateWord(slice) : liveWord} · wave ${waveOf(slice)}`, width),
+        ...workflowOverview(execution, width),
         { text: `  declared    ${declaredWord} (slice file)` },
-        actionRow(`evidence    ${evidence}`, open("evidence"), width),
+        actionRow(slice.readiness?.configured ? `proof ${slice.readiness.state} · inspect judgments and evidence` : `evidence    ${evidence}`, open("evidence"), width),
         { text: `  assignment  ${slice.lane ? `${str(slice.lane["seat"])} · ${str(activity["activity"], INDETERMINATE)} (${str(activity["decided_by"], "?")})` : "none — no claimed lane"}`, ...(slice.lane ? { action: open(laneKey(slice.lane)) } : {}) },
         { text: `  next        ${next}` },
         { text: `  problem     ${problem ?? "none on the projection's current surfaces"}` },
+        ...planningLines(execution, width), ...planningLines(execution, width, waveOf(slice), true),
     ];
 }
 //# sourceMappingURL=execution-model.js.map