{I.brand}devrails.ai

happily

WORKSPACE

Work

{items.map(([ic, lbl, n, on, isHot]) => (

{I[ic]}{lbl} {n && {n}}

))}

Project

{I.gear}Configure

{I.collapse}Collapse

raghu.rajah

owner · happily

); } /* micro workflow — one dot per step of THIS item's own workflow */ function Micro({ n, cur, fail, cap = 7 }) { const show = Math.min(n, cap), over = n - show; return {Array.from({ length: show }).map((_, i) => )} {over > 0 && +{over}}; } const AG = { arch: 'ARCH', code: 'CODE', docs: 'DOCS', rsch: 'RSCH', dsgn: 'DSGN', you: 'YOU' }; function TreeRow({ n }) { /* an area — one row, its questions open in the canvas, not here */ if (n.kind === 'area') return (

{n.name}
{n.sub &&
{n.sub}
}

{n.openCount ? {n.openCount} open : {n.total}}

); /* a document — an artifact of the epic, not agent work */ if (n.kind === 'doc') return (
{I.doc}
{n.name}
{n.by}

{n.state === 'you' && you}{n.state === 'now' && }

); return (

{n.name}
{(n.agent || n.sub) &&
{n.agent && {n.who || AG[n.agent]}} {n.sub && {n.sub}}
}

{n.flow && } {n.kind === 'child' && {I.ext}}

); } const STAGES = ['Groom', 'Plan', 'Build', 'Validate', 'Ship']; function EpicStage({ at, done }) { return (
{STAGES.map((s, i) => { const st = done || i < at ? 'done' : i === at ? 'now' : ''; return
{s}
; })}
); } /* epic-level spend: what the agents have burned, and what is left */ function Meter({ cells }) { return
{cells.map((c, i) =>
{c[0]}{c[1]}
)}
; } function Tree({ title, id, sub, stage = 0, stageDone, filter = 'All', nodes, footNote, meter, filters = ['All', 'Needs you', 'Running'] }) { return (

{I.chevL} All epics

{title}

{id}·{sub}
{meter && }

{filters.map((f, i) => {f})}

{nodes.map((n, i) => n.grp ?
{n.grp}
: )}
{footNote &&
{footNote}
}
); } /* per-item workflow — past steps are the ones with something to open; upcoming steps hold nothing yet, so they collapse into one dim preview */ function Flow({ steps, cur, restLabel, showPast = 3 }) { const past = steps.slice(0, cur), ahead = steps.slice(cur + 1); const shown = past.slice(-showPast), folded = past.length - shown.length; return (
{folded > 0 && <>
{Array.from({ length: Math.min(folded, 3) }).map((_, i) => )}
+{folded} earlier
open any of them
{I.chev}} {shown.map((s, i) =>
{I.tick}
{s.n}
{s.out || 'done'}
{I.chev} )}
{steps[cur].n}
{steps[cur].w}
{ahead.length > 0 && <> {I.chev}

{ahead.map(s => s.n).join(' · ')}
not started — nothing to open yet
{ahead.some(s => s.gate) && you, later}
}

{restLabel}

); } function Att({ tone = 'you', k, t, s, actions }) { return (
{tone === 'calm' ? I.spark : I.bell}
{k}
{t}
{s &&
{s}
}

{actions}

); } function WorkTop({ crumb, right }) { return (

{crumb.map((c, i) => {i > 0 && /}{c})}

{right}
); } function Sec({ h, c, right }) { return
{h}
{c && {c}}{right}
; } /* storyline drawer */ function Ev({ e }) { return (

{e.who}{e.tag && {e.tag}}{e.when}

{e.body}
{e.dec &&
Decision recorded{e.dec}
} {e.more && {e.more}}
); } function Story({ mode = 'shut', count, days, ask }) { if (mode === 'shut') return (
{I.chevL} Storyline {count}
); return (

Storyline{count}{I.chev}

Everything the agents did on this epic, newest first.

{days.map((d, i) => (
{d.day}
{d.events.map((e, j) => )} ))}
{ask &&

{I.search}{ask.q}
{ask.a &&
{ask.a}
{ask.src.map((s, i) => {s})}
}
}
); } function TaskPanel({ task, tab = 'Task', days }) { return (

Task Storyline {I.chev}

{task.nm}

{task.id}·{task.state}

Agent

{task.agent}
{task.agentName}
{task.machine}

Its workflow

{task.flow.map((s, i) =>
{i < task.cur ? I.tick : ''}
{s.n}
{s.w}

)}

Spent on this task

{task.spend.map((s, i) =>
{s[0]}{s[1]}
)}
{task.note && <>
{task.noteK}
{task.note}
}
Runs on this task
{days.map((e, i) => )}

{task.actions}

); } Object.assign(window, { I, Icon, Rail, Meter, EpicStage, TaskPanel, Tree, TreeRow, Micro, Flow, Att, WorkTop, Sec, Story, Ev, AG });