// ═══════════════════════════════════════════════════════════════════ // WORKFLOW — the intelligence pipeline, per project. // 01 Parse & Comprehend → KB + Knowledge Graph // 02 Deep Research → background · cross-checks · market // 03 Build Report → compose · human gate · publish // Reads run state from window.INTEL; renders one run per project. // ═══════════════════════════════════════════════════════════════════ (function () { const I = window.INTEL; const SCHEMA = window.REPORT_SCHEMA; // a project's asset class — drives the class-specific anatomy (RS-10/11/12) const classIdFor = (proj) => (window.AssetClass ? window.AssetClass.of(proj) : (proj.tenant === "saxcap" ? "realEstate" : "equity")); const classNameFor = (proj) => (((SCHEMA && SCHEMA.ASSET_CLASSES) || []).find((c) => c.id === classIdFor(proj)) || {}).name || "—"; const groupsFor = (proj) => (SCHEMA && SCHEMA.groupsForClass ? SCHEMA.groupsForClass(classIdFor(proj)) : (SCHEMA && SCHEMA.GROUPS) || []); // ── schema coupling ──────────────────────────────────────────────── // Every card in the instantiated structure declares the step that // fills it. Invert that per project: per step → how many cards. const cardFillsFor = (groups) => { const m = {}; groups.forEach((g) => g.subs.forEach((sub) => sub.cards.forEach((c) => { const step = c[2]; const e = m[step] || (m[step] = { cards: 0, groups: new Set() }); e.cards += 1; e.groups.add(g.id); }))); return m; }; // per-run explicit gaps, by schema group — cards that are PRESENT but // carry a named evidence gap. An explicit gap passes the gate; silence // (a missing card) does not. Each gap: ref · the sub-section it sits in // · what is missing. const RUN_GAPS = { "RUN-032": { // SAXCAP · Lionsgate — 8 named gaps G2: [ { ref: "G-03", where: "Site & Program", note: "Coaster IP — builder US Thrill Rides in Ch.11 since Dec 2022; “exclusive rights” unevidenced." }, { ref: "G-02", where: "Brand & Demand", note: "Lionsgate Orlando license unverified — LEWO operates in Hengqin only; the 2021 Wallack license lost financing." }, ], G3: [ { ref: "G-06", where: "Capital Stack & Terms", note: "Sources-and-uses bridge — ~$102.5M between $747.5M cost and $850M raise unaccounted." }, { ref: "G-04", where: "Structure & Rails", note: "Issuer SPV / series structure undisclosed — prerequisite for Form D and the token scope." }, { ref: "G-05", where: "Structure & Rails", note: "Regulated rails unnamed — no broker-dealer of record, transfer agent or ATS." }, ], G4: [ { ref: "X-08", where: "Revenue Drivers", note: "Per-cap inputs $84 / $46 run ~70% above the deck's own cited benchmark ($43.61 / $36.46)." }, ], G5: [ { ref: "G-01", where: "Control & Entitlements", note: "Land control stack — Skyplex cancelled 17 Oct 2024, site listed for sale; JV not evidenced." }, { ref: "G-07", where: "Cross-checks", note: "Primary citations pending — occ / ADR, $94.5B impact and principals' bios are dossier-attributed." }, ], }, "RUN-016": { // Raisable — 7 named gaps (mirrors the dossier's GAP-01…GAP-07 register) G2: [ { ref: "GAP-03", where: "Go-to-Market", note: "Alliance execution — TX & Texture at signature; definitive docs circulating, not countersigned." }, ], G3: [ { ref: "GAP-05", where: "Offering Terms", note: "Anchor commitment — the round opens cold; no lead to anchor the SAFE ($0 committed)." }, { ref: "GAP-06", where: "Legal Framework", note: "Portal + verification provider — no funding portal selected; no 506(c) verification provider contracted." }, ], G4: [ { ref: "GAP-07", where: "Cap Table & Proceeds", note: "Dilution stack — SAFE ~16.9% + TX founding tier + 10% Class B pool not modeled together." }, { ref: "GAP-04", where: "Market", note: "Pool / TAM / SAM sizing states a methodology but cites no sources — treated as assumption." }, ], G5: [ { ref: "GAP-01", where: "Entity Background", note: "Not yet incorporated — articles drafted to filing standard but unfiled; no EIN, no statements." }, { ref: "GAP-02", where: "Compliance", note: "EIN + bank / escrow account — no account exists; SAFE closing mechanics blocked." }, ], }, }; // each step EMITS a named artifact; provenance = the inputs it derives from const T = window.WORKFLOW_TEMPLATE; const STEP_ARTIFACT = T.STEP_ARTIFACT; const PHASES = T.PHASES; // ── asset-class branches — extra Deep Research steps per class ──── const WORKFLOW_BRANCHES = T.RESEARCH; // build the phase list for a project, injecting its asset-class branch // into Deep Research (02) just before gap synthesis. const phasesFor = (proj) => { const branch = (WORKFLOW_BRANCHES[classIdFor(proj)] || []).map((s) => ({ ...s, branch: classNameFor(proj) })); if (!branch.length) return PHASES; return PHASES.map((ph) => { if (ph.n !== "02") return ph; const steps = []; ph.steps.forEach((s) => { if (s.id === "gaps") steps.push(...branch); steps.push(s); }); return { ...ph, steps }; }); }; // run-state map including branch steps: a branch inherits "done" when // the phase's tracked steps are all done, otherwise stays queued. const effStepsFor = (proj, phases) => { const base = { ...((proj.run && proj.run.steps) || {}) }; phases.forEach((ph) => { const known = ph.steps.map((s) => s.id).filter((id) => base[id] != null); const allDone = known.length > 0 && known.every((id) => base[id] === "done"); ph.steps.forEach((s) => { if (base[s.id] == null) base[s.id] = allDone ? "done" : "queued"; }); }); return base; }; const wfMono = (s, extra) => {s}; function PhaseCard({ ph, steps }) { const done = ph.steps.filter((s) => steps[s.id] === "done").length; const running = ph.steps.some((s) => steps[s.id] === "running"); const pct = Math.round((done / ph.steps.length) * 100); return (
{ph.n} {done === ph.steps.length ? "complete" : running ? "running" : "queued"}
{ph.name}
{done}/{ph.steps.length}
); } function StepRow({ step, nn, steps, metric, go, cardFills, composeFills }) { const status = steps[step.id] || "queued"; const st = I.STEP_STATUS[status] || I.STEP_STATUS.queued; const running = status === "running"; const art = STEP_ARTIFACT[step.id]; const emitted = status === "done"; return (
{nn}
{step.name} {step.gate && human gate} {step.branch && {step.branch} branch}

{step.desc}

{art && (
⧉ {art.id} {art.name} ← {art.from} {step.composes && composeFills && composeFills[step.id] ? assembles {composeFills[step.id].cards} cards · {composeFills[step.id].groups} section{composeFills[step.id].groups > 1 ? "s" : ""} : (cardFills[step.id] && fills {cardFills[step.id].cards} card{cardFills[step.id].cards > 1 ? "s" : ""} · {cardFills[step.id].groups.size} grp)} {emitted && art.to && } {!emitted && pending}
)}
{step.agent}
{metric || "—"}
{st.label}
); } // ── schema coverage — does this run hold a complete set of data? ─── function CoveragePanel({ proj, run, go }) { const groups = groupsFor(proj); const gapMap = RUN_GAPS[run.id] || {}; const stepDone = (step) => run.steps[step] === "done"; const rows = groups.map((g) => { let total = 0, missing = 0; g.subs.forEach((sub) => sub.cards.forEach((c) => { total += 1; if (!stepDone(c[2])) missing += 1; })); const gaps = gapMap[g.id] || []; const gap = Math.min(gaps.length, total - missing); const filled = total - missing - gap; return { g, label: g.label, total, filled, gap, gaps, missing }; }); const sum = rows.reduce((a, r) => ({ total: a.total + r.total, filled: a.filled + r.filled, gap: a.gap + r.gap, missing: a.missing + r.missing }), { total: 0, filled: 0, gap: 0, missing: 0 }); const composed = stepDone("compose"); const clear = composed && sum.missing === 0; const Bar = ({ r }) => ( {r.filled > 0 && } {r.gap > 0 && } {r.missing > 0 && } ); return (
Schema Coverage — RPT-v3
{clear ? "coverage clear" : composed ? "gaps tracked" : "not yet composed"} {sum.filled} / {sum.total} cards filled · {sum.gap} explicit gap{sum.gap === 1 ? "" : "s"} · {sum.missing} missing — {clear ? "every required card is filled or explicitly gapped; the report may publish." : sum.missing > 0 ? "missing cards block the publish gate." : "compose to populate the matrix."} {[["filled", "var(--ok)"], ["gap", "var(--warn)"], ["missing", "var(--err)"]].map(([l, c]) => ( {wfMono(l)} ))}
Group Section · {classNameFor(proj)} Coverage Cards RS
{rows.map((r) => (
{r.g.id} {!r.g.req && } {r.label} {r.filled} filled {r.gap > 0 && · {r.gap} gap} {r.missing > 0 && · {r.missing} missing} {r.g.rs.join(" ")}
{r.gaps.length > 0 && (
{r.gaps.map((gp) => (
{gp.ref} {gp.where} {gp.note}
))}
)} ))}

Coverage is computed from run state × the schema's per-card step map — not asserted. Gaps are the open evidence items (RS-07); the review gate signs off on them explicitly.

); } function IntelWorkflow({ proj, tenant, go }) { const run = proj.run; const stage = I.STAGES[proj.stage]; const cardFills = cardFillsFor(groupsFor(proj)); const phases = phasesFor(proj); // per compose sub-step → the report cards it assembles (its groups × cards) const composeFills = (() => { const grp = groupsFor(proj); const out = {}; phases.forEach((ph) => ph.steps.forEach((s) => { if (!s.composes) return; const gset = new Set(s.composes); let cards = 0, gn = 0; grp.forEach((g) => { if (gset.has(g.id)) { gn += 1; g.subs.forEach((sub) => { cards += sub.cards.length; }); } }); out[s.id] = { cards, groups: gn }; })); return out; })(); const effSteps = effStepsFor(proj, phases); let nn = 0; return (
{wfMono([("run " + run.id), run.trigger, ("started " + run.started)].join(" · "), { color: "var(--ink-3)" })}
}>
{stage.label} {classNameFor(proj)} class {proj.stats.stepsDone} of {proj.stats.stepsTotal} steps complete · {stage.note}{run.version !== "—" ? " · report " + run.version : ""}{run.reviewer ? " · reviewer: " + run.reviewer : ""}
{phases.map((ph) => )}
{phases.map((ph) => (
{ph.n} · {ph.name}
# Step Agent Output Status
{ph.steps.map((s) => { nn += 1; return ; })}
))}

Inputs come from the Artifact Registry · outputs version into the Document Library · the published report renders on the Intelligence page.

); } window.IntelWorkflow = IntelWorkflow; })();