{isTicket
? "Created with the finding, evidence queries and recommended action attached."
: "Created with the before→after projection and source DQL — ready to share."}
{action.ref}
{action.simulated && (
Demo mode — live export creates a real notebook when connected to a Dynatrace tenant.
)}
)}
);
}
/* ------------------------------------------------------------- run store ---- */
const initialRun = {
phase: "idle", // idle | investigating | done | error
planSteps: [], // [{ id, description }]
completed: {}, // stepId -> step.completed payload
runningId: null,
oppsRaw: [], // contract opportunities, arrival order
rankedIds: [],
verdict: null, // contract verdict (validate-task runs) — adapted at render time
selfStats: null, // { tokens, seconds, queries, scannedGB }
error: null,
};
function runReducer(state, action) {
if (action.type === "reset") return initialRun;
if (action.type !== "event") return state;
const ev = action.ev;
switch (ev.type) {
case "run.started":
return { ...initialRun, phase: "investigating" };
case "plan.proposed":
return { ...state, planSteps: ev.steps };
case "step.started":
return { ...state, runningId: ev.stepId };
case "step.completed":
return {
...state,
completed: { ...state.completed, [ev.stepId]: ev },
runningId: state.runningId === ev.stepId ? null : state.runningId,
};
case "opportunity.added":
return { ...state, oppsRaw: [...state.oppsRaw, ev.opportunity] };
case "board.ready":
return { ...state, rankedIds: ev.rankedOpportunityIds };
case "verdict.ready":
return { ...state, verdict: ev.verdict };
case "run.completed":
return {
...state,
phase: "done",
selfStats: {
tokens: ev.estCost?.tokens ?? 0,
seconds: +(ev.totalDurationMs / 1000).toFixed(1),
queries: ev.queryCount,
scannedGB: ev.estCost?.grailGbScanned ?? 0,
},
};
case "error":
return { ...state, phase: "error", error: ev.message };
default:
return state;
}
}
/* ----------------------------------------------------------------- App ---- */
function App() {
const [screen, setScreen] = useS("objective");
const [mode, setMode] = useS("discovery"); // discovery | validation
const [objective, setObjective] = useS(null);
const [task, setTask] = useS("");
const [detailId, setDetailId] = useS(null);
const [drawerQ, setDrawerQ] = useS(null); // query view-model | null
const [action, setAction] = useS(null);
const [artifacts, setArtifacts] = useS({});
const [runId, setRunId] = useS(null);
const [pendingBoard, setPendingBoard] = useS(false); // jump to board when the run is ready
const [run, dispatch] = useReducer(runReducer, initialRun);
const closeRef = useRefApp(null);
const go = useCallback((s) => { setScreen(s); window.scrollTo({ top: 0 }); }, []);
// Start a live run (SSE) for an objective and stream its events into the reducer. Used by both
// Discovery and Validation — Discovery ends in a ranked board, Validation (kind:"validate-task")
// emits a verdict.ready event the verdict screen renders.
const startRun = (o) => {
dispatch({ type: "reset" });
setRunId(null);
if (closeRef.current) closeRef.current();
MinervaTransport.startRun(o)
.then(({ runId }) => {
setRunId(runId);
closeRef.current = MinervaTransport.streamRun(
runId,
(ev) => dispatch({ type: "event", ev }),
() => dispatch({ type: "event", ev: { type: "error", message: "stream lost" } }),
);
})
.catch((e) => dispatch({ type: "event", ev: { type: "error", message: e.message } }));
};
const pickObjective = (o) => {
setMode("discovery");
setObjective(o);
setTask("");
setPendingBoard(false);
go("investigation");
startRun(o);
};
const startValidation = ({ task, scope }) => {
const o = { id: "validation", kind: "validate-task", title: task, statement: task, scope };
setMode("validation");
setTask(task);
setObjective(o);
setPendingBoard(false);
go("investigation");
// Run a real validate-task run; it emits verdict.ready before run.completed.
startRun(o);
};
// Redirect from a verdict back into Discovery.
const runDiscovery = (objId) => {
const o = window.MinervaData.objectives.find((x) => x.id === objId) || { id: "perf", title: "Improve Performance" };
pickObjective(o);
};
// "See the finding now" — run Discovery and jump straight to the board when it's ready.
const jumpToOpp = (_oppId) => {
const o = window.MinervaData.objectives.find((x) => x.id === "perf") || { id: "perf", title: "Improve Performance" };
setMode("discovery");
setObjective(o);
setTask("");
setPendingBoard(true);
go("investigation");
startRun(o);
};
useE(() => () => { if (closeRef.current) closeRef.current(); }, []);
// Deep-link / demo helper: ?objective= auto-starts that run on load.
useE(() => {
const id = new URLSearchParams(location.search).get("objective");
if (!id) return;
const o = window.MinervaData.objectives.find((x) => x.id === id);
if (o) pickObjective(o);
}, []);
const openDetail = (id) => { setDetailId(id); go("detail"); };
const completeInvestigation = () => go(mode === "validation" ? "verdict" : "board");
const back = () => {
if (screen === "detail") go("board");
else if (screen === "board") go("investigation");
else if (screen === "verdict") go("investigation");
else if (screen === "investigation") go("objective");
};
const home = () => {
if (closeRef.current) closeRef.current();
dispatch({ type: "reset" });
setRunId(null);
setMode("discovery"); setObjective(null); setTask(""); setDetailId(null);
setPendingBoard(false);
go("objective");
};
// Derive the screens' view-models from the live run.
const steps = run.planSteps.map((s, i) => {
const c = run.completed[s.id];
const vm = MinervaTransport.adaptStep(s, c, i);
vm.status = c ? "done" : s.id === run.runningId ? "running" : "pending";
return vm;
});
const progress = steps.filter((s) => s.status === "done").length;
const boardReady = run.rankedIds.length > 0 || run.phase === "done";
const validationReady = run.verdict != null || run.phase === "done";
const investigationDone = mode === "validation" ? validationReady : boardReady;
const orderedRaw = run.rankedIds.length
? run.rankedIds.map((id) => run.oppsRaw.find((o) => o.id === id)).filter(Boolean)
: run.oppsRaw;
const opps = orderedRaw.map((o, i) => MinervaTransport.adaptOpportunity(o, i + 1));
const oppById = (id) => opps.find((o) => o.id === id) || null;
// Deep-link / demo helper: ?goto=board (or the verdict "see the finding now" redirect) jumps to
// the board once the run is ready.
const gotoBoard = new URLSearchParams(location.search).get("goto") === "board";
useE(() => {
if ((gotoBoard || pendingBoard) && boardReady && screen === "investigation") {
setPendingBoard(false);
go("board");
}
}, [gotoBoard, pendingBoard, boardReady, screen]);
// Settle the open modal + remember the artifact for the opportunity.
const finishAction = (opp, type, ref, opts = {}) => {
setArtifacts((a) => ({ ...a, [opp.id]: { type, ref } }));
setAction((a) => (a ? { ...a, ref, url: opts.url || null, status: "done", simulated: !!opts.simulated } : a));
};
const runAction = (opp, type) => {
const simulatedRef =
type === "ticket"
? "OPS-" + (4800 + opp.rank * 7)
: "minerva/" + opp.service + (opp.endpoint || "").replace(/[^a-z]/gi, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") + ".notebook";
setAction({ opp, type, status: "creating", key: opp.id + type + Date.now() });
// Real notebook export when we have a live run; ticket export stays simulated (out of MVP).
if (type === "notebook" && runId) {
MinervaTransport.exportOpportunity(runId, opp.id)
.then(({ url }) => finishAction(opp, type, url, { url }))
// Fixture mode / no tenant: fall back to a simulated artifact so the demo completes.
.catch(() => finishAction(opp, type, simulatedRef, { simulated: true }));
return;
}
setTimeout(() => finishAction(opp, type, simulatedRef, { simulated: true }), 1000);
};
const showFooter = screen !== "objective";
return (