@openrig/cli 0.5.0 → 0.5.2

package/node_modules/@openrig/daemon/dist/domain/slices/slice-detail-projector.js

@@ -0,0 +1,672 @@
+// Slice Story View v0 + v1 — per-tab payload projector.
+//
+// Given a SliceRecord (from SliceIndexer), this assembles the full
+// per-slice payload covering all six tabs: Story, Acceptance, Decisions,
+// Docs, Tests/Verification, Topology. Read-only; no mutations. Composes
+// already-shipped tables (queue_items, queue_transitions,
+// mission_control_actions, workflow_specs, workflow_instances,
+// workflow_step_trails) + slice docs on disk + dogfood-evidence.
+//
+// v1 enrichment (per slices/slice-story-view-v1/IMPLEMENTATION-PRD.md):
+// when a workflow_instance is bound to the slice, four dimensions
+// activate — spec-graph topology, spec-driven phase tagging, current-
+// step + allowed exits in Acceptance, routing-type edge metadata
+// (default `direct` only at v1 per audit-row-6 carve-out).
+//
+// v0 hardcoded legacy phase taxonomy ("discovery"/"product-lab"/
+// "delivery"/"lifecycle"/"qa"/"other") is REMOVED at v1 per PRD § Write
+// Set Sketch. StoryEvent.phase is now an open-ended string-or-null:
+// when bound to a workflow_instance, the value is the spec-defined
+// step.id; otherwise null (UI groups under "Untagged").
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { sessionRigOf } from "../session-name.js";
+import { findSliceWorkflowBinding, } from "../workflow/slice-workflow-binding.js";
+import { isScaffoldPlaceholderText, GENERIC_SCAFFOLD_ACCEPTANCE, } from "../scope/scaffold-placeholder.js";
+// VM-006 (progress-review-done-coherence): the QA-verdict union reuses
+// Review's OWN exported derivation pair + the ONE proof-artifact reader
+// (arch A1 one-home) — never a second derivation. Cycle-free: compose is
+// pure and proof-io imports only compose + node; nothing in review imports
+// slices.
+import { extractProofContractSelected, composeDelivered, parseLogicalCheckboxes, } from "../review/compose.js";
+import { readProofArtifacts } from "../review/proof-io.js";
+import { isNodeFile, resolveNodeFile } from "../scope/node-file.js";
+import { projectSpecGraph, projectPhaseDefinitions, projectCurrentStep, } from "../workflow/slice-workflow-projection.js";
+/** VM-006 (arch PIN-C): the ONE key behind the acceptance dedup, the
+ *  Progress↔Review join, and the FS-1 guard. VERBATIM the historical dedup
+ *  expression — trim + casefold, and deliberately NO whitespace collapse.
+ *
+ *  Sharing a single helper across all three is what makes join-relation ==
+ *  dedup-relation a fact of the code rather than a claim. A join key that is
+ *  COARSER than the dedup key (e.g. one that strips inline images, so that
+ *  `X ![shot](a.png)` and a plain `X` collapse together) maps two distinct
+ *  acceptance rows onto one obligation and silently lifts the wrong row —
+ *  that is the B1 collision this successor exists to kill. */
+function textKey(text) {
+    return text.trim().toLowerCase();
+}
+export class SliceDetailProjector {
+    db;
+    indexer;
+    workflowSpecCache;
+    constructor(opts) {
+        this.db = opts.db;
+        this.indexer = opts.indexer;
+        this.workflowSpecCache = opts.workflowSpecCache;
+    }
+    project(slice) {
+        // v1: resolve workflow_instance binding once; the bound spec drives
+        // four downstream dimensions (story phase tags, spec graph, current
+        // step, phase definitions). When unbound or when the spec is no
+        // longer cached (operator deleted the spec file, etc.), all v1
+        // fields return null and v0 fallbacks apply.
+        const bindingResult = findSliceWorkflowBinding(this.db, slice.qitemIds);
+        const binding = bindingResult.primary;
+        const spec = binding && this.workflowSpecCache
+            ? this.tryGetSpec(binding.workflowName, binding.workflowVersion)
+            : null;
+        const trailQitemToStep = binding ? this.buildTrailQitemToStepMap(binding.instanceId) : new Map();
+        return {
+            name: slice.name,
+            missionId: slice.missionId,
+            slicePath: slice.slicePath,
+            displayName: slice.displayName,
+            railItem: slice.railItem,
+            status: slice.status,
+            rawStatus: slice.rawStatus,
+            qitemIds: slice.qitemIds,
+            commitRefs: slice.commitRefs,
+            lastActivityAt: slice.lastActivityAt,
+            workflowBinding: binding ? {
+                instanceId: binding.instanceId,
+                workflowName: binding.workflowName,
+                workflowVersion: binding.workflowVersion,
+                status: binding.status,
+                currentStepId: binding.currentStepId,
+                currentFrontier: binding.currentFrontier,
+                hopCount: binding.hopCount,
+                createdAt: binding.createdAt,
+                completedAt: binding.completedAt,
+                additionalInstanceIds: bindingResult.additionalInstanceIds,
+            } : null,
+            story: {
+                events: this.buildStory(slice, trailQitemToStep),
+                phaseDefinitions: spec ? projectPhaseDefinitions(spec) : null,
+            },
+            acceptance: {
+                ...this.buildAcceptance(slice),
+                currentStep: spec && binding
+                    ? projectCurrentStep(spec, binding.currentStepId, binding.hopCount, binding.status)
+                    : null,
+            },
+            decisions: { rows: this.buildDecisions(slice) },
+            docs: { tree: this.buildDocsTree(slice) },
+            tests: this.buildTests(slice.proofPacket),
+            topology: {
+                ...this.buildTopology(slice),
+                specGraph: spec && binding ? projectSpecGraph(spec, binding.currentStepId) : null,
+            },
+        };
+    }
+    // --- v1 helpers ---
+    tryGetSpec(name, version) {
+        if (!this.workflowSpecCache)
+            return null;
+        try {
+            const row = this.workflowSpecCache.getByNameVersion(name, version);
+            return row?.spec ?? null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Builds a qitem_id → step_id map by reading the bound instance's
+     * workflow_step_trails. Each trail row's prior_qitem_id maps to the
+     * step that closed (`step_id`), and next_qitem_id maps to the
+     * subsequent step's first packet. Used by buildStory to tag each
+     * StoryEvent with the spec-defined phase the qitem traces back to.
+     */
+    buildTrailQitemToStepMap(instanceId) {
+        const map = new Map();
+        try {
+            const trails = this.db.prepare(`SELECT step_id, prior_qitem_id, next_qitem_id
+           FROM workflow_step_trails
+           WHERE instance_id = ?`).all(instanceId);
+            for (const t of trails) {
+                // The prior_qitem_id is the one that closed AT step_id —
+                // events for that qitem belong to step_id's phase.
+                map.set(t.prior_qitem_id, t.step_id);
+            }
+        }
+        catch {
+            // workflow_step_trails absent — empty map (events untagged).
+        }
+        return map;
+    }
+    // --- Story tab ---
+    buildStory(slice, trailQitemToStep) {
+        const events = [];
+        // v1: phase tag = spec step.id from trail mapping (when bound),
+        // null otherwise. v0's hardcoded legacy phase taxonomy is gone.
+        const phaseFor = (qitemId) => qitemId ? trailQitemToStep.get(qitemId) ?? null : null;
+        if (slice.qitemIds.length > 0) {
+            const placeholders = slice.qitemIds.map(() => "?").join(",");
+            // queue_items create/handoff snapshot rows. We use the row itself as
+            // a "create" event keyed on ts_created, plus per-row state field at
+            // ts_updated. queue_transitions provides the per-transition history.
+            try {
+                // OPR.0.4.1.18: SELECT * (not an explicit column list) so a queue_items
+                // schema that predates migration 044 (no `summary` column — e.g. minimal
+                // test fixtures) does not throw here; r.summary is then undefined and the
+                // degrade below kicks in. summary is optional in the row type for the
+                // same reason.
+                const qrows = this.db.prepare(`SELECT * FROM queue_items WHERE qitem_id IN (${placeholders})`).all(...slice.qitemIds);
+                for (const r of qrows) {
+                    events.push({
+                        ts: r.ts_created,
+                        phase: phaseFor(r.qitem_id),
+                        kind: "queue.created",
+                        actorSession: r.source_session,
+                        qitemId: r.qitem_id,
+                        // OPR.0.4.1.18 (THE compat fix): prefer the authored human summary;
+                        // degrade to source→dest + body-truncation when null/absent (pre-18
+                        // qitems + any an author omitted). Keeps StoryEvent.summary non-null.
+                        summary: r.summary ?? `${r.source_session} → ${r.destination_session}: ${truncate(r.body, 100)}`,
+                        detail: { tier: r.tier, state: r.state },
+                    });
+                }
+            }
+            catch {
+                // queue_items absent — skip
+            }
+            // queue_transitions (per-state-change log; append-only per PL-004
+            // Phase A schema).
+            try {
+                const trows = this.db.prepare(`SELECT qitem_id, ts, state, transition_note, actor_session, closure_reason
+             FROM queue_transitions WHERE qitem_id IN (${placeholders})
+             ORDER BY ts, transition_id`).all(...slice.qitemIds);
+                for (const t of trows) {
+                    const note = t.transition_note ?? t.closure_reason;
+                    events.push({
+                        ts: t.ts,
+                        phase: phaseFor(t.qitem_id),
+                        kind: `transition.${t.state}`,
+                        actorSession: t.actor_session,
+                        qitemId: t.qitem_id,
+                        summary: `→ ${t.state}${note ? ` (${truncate(note, 60)})` : ""}`,
+                        detail: null,
+                    });
+                }
+            }
+            catch {
+                // queue_transitions absent — skip
+            }
+            // mission_control_actions (operator verbs; PL-005 Phase A migration 037).
+            try {
+                const arows = this.db.prepare(`SELECT action_id, acted_at, qitem_id, action_verb, actor_session,
+                  before_state_json, after_state_json, reason, annotation
+             FROM mission_control_actions WHERE qitem_id IN (${placeholders})
+             ORDER BY acted_at, rowid`).all(...slice.qitemIds);
+                for (const a of arows) {
+                    const note = a.annotation ?? a.reason;
+                    events.push({
+                        ts: a.acted_at,
+                        phase: phaseFor(a.qitem_id),
+                        kind: `mission_control.${a.action_verb}`,
+                        actorSession: a.actor_session,
+                        qitemId: a.qitem_id,
+                        summary: `${a.actor_session} ${a.action_verb}${note ? `: ${truncate(note, 60)}` : ""}`,
+                        detail: { before: a.before_state_json, after: a.after_state_json },
+                    });
+                }
+            }
+            catch {
+                // mission_control_actions absent — skip
+            }
+        }
+        // Slice doc edits (mtimes inside the slice folder). v1: no phase tag
+        // — these aren't qitem-bound so they don't trace to a spec step.
+        // UI will group them under "Untagged" or render them without a tag.
+        try {
+            const sliceDir = slice.slicePath;
+            const docEntries = fs.readdirSync(sliceDir, { withFileTypes: true });
+            for (const entry of docEntries) {
+                if (!entry.isFile() || !entry.name.endsWith(".md"))
+                    continue;
+                const st = fs.statSync(path.join(sliceDir, entry.name));
+                events.push({
+                    ts: st.mtime.toISOString(),
+                    phase: null,
+                    kind: "doc.edited",
+                    actorSession: null,
+                    qitemId: null,
+                    summary: `Doc edited: ${entry.name}`,
+                    detail: null,
+                });
+            }
+        }
+        catch {
+            // slice folder unreadable — skip
+        }
+        // Proof packet emission — single event per packet using directory mtime.
+        // v1: also untagged (not qitem-bound).
+        if (slice.proofPacket) {
+            events.push({
+                ts: slice.proofPacket.mtime,
+                phase: null,
+                kind: "proof_packet.emitted",
+                actorSession: null,
+                qitemId: null,
+                summary: `Proof packet emitted: ${slice.proofPacket.dirName}`,
+                detail: {
+                    markdownCount: slice.proofPacket.markdownFiles.length,
+                    screenshotCount: slice.proofPacket.screenshots.length,
+                    videoCount: slice.proofPacket.videos.length,
+                },
+            });
+        }
+        events.sort((a, b) => a.ts.localeCompare(b.ts));
+        return events;
+    }
+    // --- Acceptance tab ---
+    buildAcceptance(slice) {
+        const items = [];
+        // Parse README + IMPLEMENTATION-PRD + PROGRESS.md for [ ]/[x] checkbox lines.
+        // Source citation = file + 1-based line number so the operator can jump.
+        const sliceDir = slice.slicePath;
+        // Scan the SELECTED node file once. Scanning both SPEC.md and README.md on a both-present node
+        // parses the shadowed file too, so every checkbox it shares with the live one becomes a second
+        // acceptance row — a duplicated or stale contract presented as the slice's own.
+        const selectedNode = resolveNodeFile(sliceDir);
+        const candidateFiles = [
+            ...(selectedNode ? [path.basename(selectedNode)] : []),
+            "IMPLEMENTATION-PRD.md",
+            "PROGRESS.md",
+            "IMPLEMENTATION.md",
+        ];
+        // VM-006: the PRD bytes are captured during this existing scan — zero new
+        // IO for the proof-contract extraction below. PM dogfood #1: the README
+        // bytes are captured the same way (this scan already reads them) so the
+        // contract extraction can apply the per-section selection.
+        let prdContent = null;
+        let readmeContent = null;
+        for (const fname of candidateFiles) {
+            const full = path.join(sliceDir, fname);
+            if (!fs.existsSync(full))
+                continue;
+            const content = fs.readFileSync(full, "utf8");
+            if (fname === "IMPLEMENTATION-PRD.md")
+                prdContent = content;
+            // SPEC.md and the legacy README.md are the same role — whichever is present carries the
+            // node body the contract extraction below reads.
+            if (isNodeFile(fname) && readmeContent === null)
+                readmeContent = content;
+            // qitem-render-driver B — the SHARED logical-checkbox relation (the
+            // same parser Review's proof contract consumes). rawText carries any
+            // joined continuation and IS the VM-006 join key, so acceptance rows
+            // and promised items key off identical bytes by construction; a second
+            // parser here would silently desynchronize the QA-verdict lift.
+            for (const logical of parseLogicalCheckboxes(content)) {
+                // release-0.4.7 intent-stage (edit 1): scaffold-template placeholder
+                // rows are not acceptance items (shared grammar:
+                // ../scope/scaffold-placeholder.ts).
+                if (isScaffoldPlaceholderText(logical.rawText))
+                    continue;
+                items.push({
+                    // rawText UNCHANGED — image-bearing rows keep their authored bytes,
+                    // preserving the join relation.
+                    text: logical.rawText,
+                    done: logical.checked,
+                    source: { file: fname, line: logical.sourceLine },
+                });
+            }
+        }
+        // release-0.4.7 intent-stage (edit 2): dedup by normalized text
+        // (casefold + trim). First occurrence wins for BOTH the source jump-link
+        // and the done-state — deterministic via the candidateFiles scan order
+        // (README > IMPLEMENTATION-PRD > PROGRESS > IMPLEMENTATION).
+        const seenText = new Set();
+        const deduped = [];
+        for (const item of items) {
+            const key = textKey(item.text);
+            if (seenText.has(key))
+                continue;
+            seenText.add(key);
+            deduped.push(item);
+        }
+        // release-0.4.7 intent-stage (edit 3): skip the generic scaffold triple
+        // ONLY-WHILE-PRISTINE — all three slice-progress.md literals present,
+        // all unchecked, and they are the ONLY checkbox rows sourced from
+        // PROGRESS.md. ANY check, ANY text edit, or ANY added PROGRESS row makes
+        // them real (arch AR-6: strictest-pristine — over-count noise beats
+        // silent under-count of deliberately-kept items; deliberate-keep stays
+        // expressible by checking or editing any of the three).
+        const progressRows = deduped.filter((i) => i.source.file === "PROGRESS.md");
+        const pristineTriple = progressRows.length === GENERIC_SCAFFOLD_ACCEPTANCE.length &&
+            progressRows.every((i) => !i.done) &&
+            GENERIC_SCAFFOLD_ACCEPTANCE.every((lit) => progressRows.some((i) => i.text === lit));
+        const finalItems = pristineTriple
+            ? deduped.filter((i) => i.source.file !== "PROGRESS.md")
+            : deduped;
+        // VM-006 (progress-review-done-coherence): union the done-state for
+        // proof-contract rows — done = checkboxTicked OR qaVerified. Review
+        // derives `verified` from the QA passing verdict while the tick-state
+        // here never moves (`rig proof add` does not tick the authored box), so
+        // the two tabs disagreed about the same obligations.
+        //
+        // The join is a MULTIPLICITY-GATED 1:1 association on `textKey`, taken
+        // over the RAW authored text on BOTH sides (`promised.rawText` vs
+        // `item.text`). Raw-on-both is precisely what keeps the join relation
+        // identical to the dedup relation above. Joining the STRIPPED promised
+        // text against the raw row text would need a coarser comparator, and a
+        // coarser relation collapses two distinct rows onto one obligation — the
+        // B1 collision that false-lifted a non-contract row (guard BLOCKING on
+        // predecessor 0ec6411c).
+        //
+        // The 1:1 gate — a key reaching >1 obligation OR >1 row lifts NOTHING —
+        // makes pm's FR-2 invariants structural rather than argued: (1) lift only
+        // via a 1:1 association to a single verified obligation, and (2) the
+        // Progress verified-lift count can never exceed Review's verified count.
+        // Under raw keys the guard's two collisions become distinctions, so the
+        // gate is armed-but-vacuous on real slices; its live purpose is the
+        // degenerate case of two byte-identical authored contract lines, where
+        // fail-closed (stay ACTIVE) beats a coin-flip lift (arch AR-6).
+        //
+        // NEVER sets done=false — the author's record is never reversed (FR-3).
+        // PM dogfood #1 — the SAME per-section selection Review compose uses
+        // (one selection rule, one grammar home): an authored README contract
+        // wins over a pristine scaffold-only PRD contract, so the VM-006 lift
+        // joins against the contract the author actually wrote.
+        const promised = extractProofContractSelected(prdContent, readmeContent).items;
+        if (promised.length > 0) {
+            const promisedByKey = new Map();
+            promised.forEach((p, i) => {
+                const k = textKey(p.rawText);
+                const at = promisedByKey.get(k);
+                if (at)
+                    at.push(i);
+                else
+                    promisedByKey.set(k, [i]);
+            });
+            const rowsByKey = new Map();
+            for (const item of finalItems) {
+                const k = textKey(item.text);
+                const at = rowsByKey.get(k);
+                if (at)
+                    at.push(item);
+                else
+                    rowsByKey.set(k, [item]);
+            }
+            // FS-1 guard (arch-endorsed): buildAcceptance runs per slice across a
+            // whole mission on the Progress tab, so the proof-dir read fires ONLY
+            // when an authored contract still has an unticked row — the union can
+            // only lift, so all-ticked and contract-free slices do ZERO extra IO.
+            // Keyed by the SAME textKey as the join: a guard on a different relation
+            // could skip the read for a row the join would then have lifted.
+            const hasUntickedContractRow = finalItems.some((i) => !i.done && promisedByKey.has(textKey(i.text)));
+            if (hasUntickedContractRow) {
+                // The ONE reader Review uses (arch A1 one-home) + Review's OWN join:
+                // composeDelivered binds `verified` to the promised INDEX, and we read
+                // items[i].verified back — the verdict is never re-derived here.
+                const delivered = composeDelivered(promised, readProofArtifacts(sliceDir));
+                for (const item of finalItems) {
+                    if (item.done)
+                        continue;
+                    const k = textKey(item.text);
+                    const at = promisedByKey.get(k);
+                    if (!at || at.length !== 1)
+                        continue;
+                    if (rowsByKey.get(k)?.length !== 1)
+                        continue;
+                    if (delivered.items[at[0]].verified !== "verified")
+                        continue;
+                    item.done = true;
+                    item.doneVia = "qa-verdict";
+                }
+            }
+            for (const item of finalItems) {
+                if (item.done && item.doneVia === undefined)
+                    item.doneVia = "checkbox";
+            }
+        }
+        const total = finalItems.length;
+        const done = finalItems.filter((i) => i.done).length;
+        const pct = total === 0 ? 0 : Math.round((done / total) * 100);
+        const closureCallout = slice.status === "done"
+            ? `Goal Met (status: ${slice.rawStatus ?? "done"})`
+            : null;
+        return {
+            totalItems: total,
+            doneItems: done,
+            percentage: pct,
+            items: finalItems,
+            closureCallout,
+        };
+    }
+    // --- Decisions tab ---
+    buildDecisions(slice) {
+        if (slice.qitemIds.length === 0)
+            return [];
+        try {
+            const placeholders = slice.qitemIds.map(() => "?").join(",");
+            const rows = this.db.prepare(`SELECT action_id, acted_at, actor_session, action_verb, qitem_id,
+                before_state_json, after_state_json, reason, annotation
+           FROM mission_control_actions
+           WHERE qitem_id IN (${placeholders})
+           ORDER BY acted_at DESC, rowid DESC`).all(...slice.qitemIds);
+            return rows.map((r) => ({
+                actionId: r.action_id,
+                ts: r.acted_at,
+                actor: r.actor_session,
+                verb: r.action_verb,
+                qitemId: r.qitem_id,
+                reason: r.annotation ?? r.reason,
+                beforeState: r.before_state_json,
+                afterState: r.after_state_json,
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    // --- Docs tab ---
+    buildDocsTree(slice) {
+        const sliceDir = slice.slicePath;
+        const out = [];
+        const walk = (dir, relPrefix) => {
+            let entries;
+            try {
+                entries = fs.readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const rel = relPrefix ? `${relPrefix}/${entry.name}` : entry.name;
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    out.push({ name: entry.name, type: "dir", size: null, mtime: null, relPath: rel });
+                    walk(full, rel);
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                try {
+                    const st = fs.statSync(full);
+                    out.push({
+                        name: entry.name,
+                        type: "file",
+                        size: st.size,
+                        mtime: st.mtime.toISOString(),
+                        relPath: rel,
+                    });
+                }
+                catch {
+                    // skip
+                }
+            }
+        };
+        walk(sliceDir, "");
+        out.sort((a, b) => a.relPath.localeCompare(b.relPath));
+        return out;
+    }
+    /** Read a single doc file from the slice folder for the Docs tab. Returns null if missing or outside the slice folder. */
+    readDoc(sliceName, relPath) {
+        const slice = this.indexer.get(sliceName);
+        if (!slice)
+            return null;
+        const sliceDir = slice.slicePath;
+        const resolved = path.resolve(sliceDir, relPath);
+        if (!resolved.startsWith(`${path.resolve(sliceDir)}${path.sep}`) && resolved !== path.resolve(sliceDir)) {
+            // Path-traversal guard.
+            return null;
+        }
+        try {
+            return fs.readFileSync(resolved, "utf8");
+        }
+        catch {
+            return null;
+        }
+    }
+    // --- Tests / Verification tab ---
+    buildTests(proofPacket) {
+        if (!proofPacket) {
+            return { proofPackets: [], aggregate: { passCount: 0, failCount: 0 } };
+        }
+        const additionalMarkdown = [];
+        let primaryMarkdown = null;
+        for (let i = 0; i < proofPacket.markdownFiles.length; i++) {
+            const rel = proofPacket.markdownFiles[i];
+            const content = this.readProofAsset(proofPacket, rel) ?? "";
+            if (i === 0) {
+                primaryMarkdown = { relPath: rel, content };
+            }
+            else {
+                additionalMarkdown.push({ relPath: rel, content });
+            }
+        }
+        const passFailBadge = inferPassFailBadge(primaryMarkdown?.content ?? "");
+        const rendered = {
+            dirName: proofPacket.dirName,
+            primaryMarkdown,
+            additionalMarkdown,
+            screenshots: proofPacket.screenshots,
+            videos: proofPacket.videos,
+            traces: proofPacket.traces,
+            passFailBadge,
+        };
+        return {
+            proofPackets: [rendered],
+            aggregate: {
+                passCount: passFailBadge === "pass" ? 1 : 0,
+                failCount: passFailBadge === "fail" ? 1 : 0,
+            },
+        };
+    }
+    /**
+     * Read a proof-packet asset (markdown content or check existence of binary
+     * files like screenshots/videos). Path-traversal guarded by absPath prefix
+     * check.
+     */
+    readProofAsset(proofPacket, relPath) {
+        const resolved = path.resolve(proofPacket.absPath, relPath);
+        if (!resolved.startsWith(`${path.resolve(proofPacket.absPath)}${path.sep}`)) {
+            return null;
+        }
+        try {
+            return fs.readFileSync(resolved, "utf8");
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Returns the absolute on-disk path of a proof asset for binary serving. Path-traversal guarded. */
+    resolveProofAssetPath(proofPacket, relPath) {
+        const resolved = path.resolve(proofPacket.absPath, relPath);
+        if (!resolved.startsWith(`${path.resolve(proofPacket.absPath)}${path.sep}`)) {
+            return null;
+        }
+        try {
+            const st = fs.statSync(resolved);
+            if (!st.isFile())
+                return null;
+            return resolved;
+        }
+        catch {
+            return null;
+        }
+    }
+    // --- Topology tab ---
+    buildTopology(slice) {
+        if (slice.qitemIds.length === 0) {
+            return { affectedRigs: [], totalSeats: 0 };
+        }
+        try {
+            const placeholders = slice.qitemIds.map(() => "?").join(",");
+            const rows = this.db.prepare(`SELECT DISTINCT source_session, destination_session
+           FROM queue_items WHERE qitem_id IN (${placeholders})`).all(...slice.qitemIds);
+            const sessionsByRig = new Map();
+            for (const r of rows) {
+                for (const s of [r.source_session, r.destination_session]) {
+                    if (!s)
+                        continue;
+                    const rig = sessionRigKey(s);
+                    const set = sessionsByRig.get(rig) ?? new Set();
+                    set.add(s);
+                    sessionsByRig.set(rig, set);
+                }
+            }
+            // Resolve rig display names from the rigs table when possible. If the
+            // rig isn't registered locally (e.g., session names from another host),
+            // we keep the parsed key as a placeholder rigId.
+            const rigNames = new Map();
+            try {
+                const rigRows = this.db.prepare(`SELECT id, name FROM rigs`).all();
+                for (const r of rigRows)
+                    rigNames.set(r.name, r.id);
+            }
+            catch {
+                // rigs table unavailable — fall back to parsed key as both id and name.
+            }
+            const affectedRigs = [];
+            for (const [rigKey, sessionSet] of sessionsByRig) {
+                affectedRigs.push({
+                    rigId: rigNames.get(rigKey) ?? rigKey,
+                    rigName: rigKey,
+                    sessionNames: Array.from(sessionSet).sort(),
+                });
+            }
+            affectedRigs.sort((a, b) => a.rigName.localeCompare(b.rigName));
+            const totalSeats = Array.from(sessionsByRig.values()).reduce((sum, set) => sum + set.size, 0);
+            return { affectedRigs, totalSeats };
+        }
+        catch {
+            return { affectedRigs: [], totalSeats: 0 };
+        }
+    }
+}
+function truncate(s, n) {
+    if (s.length <= n)
+        return s;
+    return `${s.slice(0, n)}…`;
+}
+function sessionRigKey(session) {
+    // Sessions are usually "<member>@<rig>" — the rig portion is the key.
+    // Non-canonical names (no @, legacy, malformed) are their own rig key.
+    // OPR.0.4.6.MH1 FR-8: the shared parse contract (greedy first-@ rig).
+    return sessionRigOf(session) ?? session;
+}
+function inferPassFailBadge(content) {
+    if (!content)
+        return "unknown";
+    const lower = content.toLowerCase();
+    if (/\b(accept|accepted|passed|all green|all pass|fully green|green after fix|complete|✅|🟢)/.test(lower))
+        return "pass";
+    if (/\b(blocker|blocked|fail|red|🔴|❌)/.test(lower))
+        return "fail";
+    if (/\b(partial|partially|in progress|standing by)/.test(lower))
+        return "partial";
+    return "unknown";
+}
+//# sourceMappingURL=slice-detail-projector.js.map