Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import LoomShotPlanner from './LoomShotPlanner';
import { useEffect, useMemo, useState } from 'react';
import { AlertTriangle, CheckCircle2, ChevronDown, ChevronUp, CircleAlert, Loader2, Save, Sparkles, Trash2 } from 'lucide-react';
import ProviderModelSelector from '../ProviderModelSelector';
import { FormField } from '../ui/FormField.jsx';
import toast from '../ui/Toast';
import { useAsyncAction } from '../../hooks/useAsyncAction';
import useFableLoomAiRun from '../../hooks/useFableLoomAiRun';
import useProviderModels from '../../hooks/useProviderModels';
import {
generateLoomEpisodeOutline,
reviewLoomEpisodeOutline,
updateLoomEpisode,
validateLoomEpisodeOutline,
} from '../../services/api';
import { effectiveModelFor, effortAwareModelOptions } from '../../utils/providers';
import { fieldClass, labelClass } from './fieldStyles';
import LoomAiRunStatus from './LoomAiRunStatus';
import {
FABLELOOM_CHALLENGE_PHASES,
fableLoomPlotPointKind,
} from '../../../../server/lib/fableLoomOutline.js';
const asArray = (value) => (Array.isArray(value) ? value : []);
const TELEPLAY_SYNC_ISSUE_CODES = new Set([
'TELEPLAY_SCENE_MEMBERSHIP_MISMATCH',
'TELEPLAY_START_MISMATCH',
'TELEPLAY_SCENE_CONTRACT_MISMATCH',
]);
const isTeleplaySyncIssue = (issue) => TELEPLAY_SYNC_ISSUE_CODES.has(issue?.code);
const cloneOutline = (outline) => (outline ? {
...outline,
scenes: asArray(outline.scenes).map((scene) => ({
...scene,
transitions: asArray(scene.transitions).map((transition) => ({ ...transition })),
})),
validation: outline.validation ? { ...outline.validation, issues: asArray(outline.validation.issues).map((issue) => ({ ...issue })) } : {
status: 'draft', issues: [],
},
} : null);
const draftValidation = { status: 'draft', issues: [] };
function ValidationResult({ validation, teleplayReplacementReady = false }) {
if (!validation) return null;
const issues = asArray(validation.issues);
const hasErrors = !teleplayReplacementReady
&& issues.some((issue) => issue.severity !== 'warning');
const status = validation.stats
? (validation.stats.errorCount ? 'invalid' : 'valid')
: validation.status || 'draft';
const label = teleplayReplacementReady
? 'Outline is ready to replace the old teleplay'
: status === 'valid'
? 'Outline is structurally valid'
: status === 'invalid'
? 'Outline needs edits'
: 'Outline is a draft';
return (
<div className={`rounded border p-3 space-y-2 ${status === 'valid' ? 'border-port-success/40 bg-port-success/5' : hasErrors ? 'border-port-error/40 bg-port-error/5' : 'border-port-warning/40 bg-port-warning/5'}`} aria-live="polite">
<div className="flex items-center gap-2 text-sm font-semibold">
{status === 'valid' ? <CheckCircle2 size={15} className="text-port-success" /> : hasErrors ? <CircleAlert size={15} className="text-port-error" /> : <AlertTriangle size={15} className="text-port-warning" />}
{label}
{validation.stats ? <span className="ml-auto text-xs font-normal text-port-text-muted">
{validation.stats.sceneCount} beats · {validation.stats.decisionCount} choices · {validation.stats.endingCount} endings
</span> : null}
</div>
{issues.length ? (
<ul className="space-y-1 text-xs text-port-text-muted">
{issues.map((issue, index) => <li key={`${issue.code || 'issue'}-${issue.sceneKey || 'outline'}-${index}`} className="flex items-start gap-1.5">
{issue.severity === 'warning' || teleplayReplacementReady ? <AlertTriangle size={12} className="mt-0.5 shrink-0 text-port-warning" /> : <CircleAlert size={12} className="mt-0.5 shrink-0 text-port-error" />}
<span>{issue.message}</span>
</li>)}
</ul>
) : status === 'valid' ? (
<p className="text-xs text-port-success">Every beat is reachable, choices are distinct, and each path reaches an ending.</p>
) : null}
</div>
);
}
function OutlineBeat({
scene, index, scenes, plotPoints, onChange, onRemovePath, onAddPath, expanded, onToggle,
}) {
const possibleTargets = scenes.filter((candidate) => candidate.key !== scene.key);
const selectedPlotPoint = plotPoints.find((item) => item.id === scene.plotPointId) || null;
return (
<article className="rounded-lg border border-port-border bg-port-bg/40" data-testid={`outline-beat-${scene.key}`}>
<button
type="button"
onClick={onToggle}
className="flex w-full items-start justify-between gap-3 p-3 text-left hover:bg-port-bg/60"
aria-expanded={expanded}
>
<span className="flex min-w-0 items-start gap-2">
<span className="mt-0.5 flex h-5 w-5 shrink-0 items-center justify-center rounded-full bg-port-accent/15 text-[10px] font-semibold text-port-accent">{index + 1}</span>
<span className="min-w-0">
<span className="block break-words text-sm font-semibold">{scene.title || 'Untitled beat'}</span>
<span className="mt-1 block break-words text-xs text-port-text-muted">{scene.summary || 'No log-line yet.'}</span>
{scene.challengePhase ? (
<span className="mt-1 inline-flex rounded bg-port-accent/10 px-1.5 py-0.5 text-[10px] font-medium uppercase tracking-wide text-port-accent">
{scene.challengePhase}
</span>
) : null}
</span>
</span>
{expanded ? <ChevronUp size={15} className="shrink-0 text-port-text-muted" /> : <ChevronDown size={15} className="shrink-0 text-port-text-muted" />}
</button>
{expanded ? (
<div className="space-y-3 border-t border-port-border p-3">
<FormField label="Beat title" labelClassName={labelClass}>
<input
className={fieldClass}
value={scene.title || ''}
onChange={(event) => onChange({ title: event.target.value })}
/>
</FormField>
<FormField label="Log-line / summary" labelClassName={labelClass} hint="What changes in this camera-cut beat, and why does it matter?">
<textarea
rows={3}
className={fieldClass}
value={scene.summary || ''}
onChange={(event) => onChange({ summary: event.target.value })}
/>
</FormField>
{plotPoints.length ? (
<div className="grid gap-2 sm:grid-cols-2">
<FormField label="Mapped plot point" labelClassName={labelClass} hint="Connect this beat to the durable series-plan item it realizes.">
<select
className={fieldClass}
value={scene.plotPointId || ''}
onChange={(event) => {
const plotPointId = event.target.value || null;
const selected = plotPoints.find((item) => item.id === plotPointId);
onChange({
plotPointId,
challengePhase: fableLoomPlotPointKind(selected) === 'challenge'
? scene.challengePhase || 'setup'
: null,
});
}}
>
<option value="">Not mapped</option>
{plotPoints.map((item) => (
<option key={item.id} value={item.id}>
{fableLoomPlotPointKind(item) === 'challenge' ? 'Challenge: ' : ''}{item.title || 'Untitled plot point'}
</option>
))}
</select>
</FormField>
{fableLoomPlotPointKind(selectedPlotPoint) === 'challenge' ? (
<FormField label="Challenge phase" labelClassName={labelClass} hint="Every challenge needs all five phases before validation passes.">
<select
className={fieldClass}
value={scene.challengePhase || 'setup'}
onChange={(event) => onChange({ challengePhase: event.target.value })}
>
{FABLELOOM_CHALLENGE_PHASES.map((phase) => (
<option key={phase} value={phase}>{phase[0].toUpperCase() + phase.slice(1)}</option>
))}
</select>
</FormField>
) : null}
</div>
) : null}
<div className="grid grid-cols-2 gap-2">
<label className={labelClass}>
Playback
<select className={`${fieldClass} mt-1`} value={scene.playbackMode || 'decision'} onChange={(event) => onChange({ playbackMode: event.target.value })}>
<option value="cut">Automatic cut</option>
<option value="decision">Viewer choice</option>
</select>
</label>
<label className={labelClass}>
Audience channel
<select className={`${fieldClass} mt-1`} value={scene.audienceConnection || 'disconnected'} onChange={(event) => onChange({ audienceConnection: event.target.value })}>
<option value="disconnected">Disconnected</option>
<option value="connected">Connected</option>
</select>
</label>
</div>
<label className="flex items-center gap-2 text-xs text-port-text-muted">
<input type="checkbox" checked={scene.isEnding === true} onChange={(event) => onChange({ isEnding: event.target.checked })} />
Ending beat
</label>
{scene.isEnding ? (
<FormField label="Ending label" labelClassName={labelClass}>
<input className={fieldClass} value={scene.endingLabel || ''} onChange={(event) => onChange({ endingLabel: event.target.value })} />
</FormField>
) : (
<div className="space-y-2">
<div className="flex items-center justify-between">
<h4 className="text-xs font-semibold uppercase tracking-wide text-port-text-muted">Paths to the next beat</h4>
<button type="button" onClick={onAddPath} className="text-xs text-port-accent hover:underline">+ Add path</button>
</div>
{asArray(scene.transitions).map((transition, transitionIndex) => (
<div key={`${scene.key}-path-${transitionIndex}`} className="flex items-start gap-2">
<div className="min-w-0 flex-1 space-y-1">
<input
className={fieldClass}
aria-label={`Path ${transitionIndex + 1} choice label for ${scene.title || scene.key}`}
placeholder="choice label"
value={transition.intent || ''}
onChange={(event) => onChange({ transitions: asArray(scene.transitions).map((item, index) => index === transitionIndex ? { ...item, intent: event.target.value } : item) })}
/>
<select
className={fieldClass}
aria-label={`Path ${transitionIndex + 1} destination for ${scene.title || scene.key}`}
value={transition.targetKey || ''}
onChange={(event) => onChange({ transitions: asArray(scene.transitions).map((item, index) => index === transitionIndex ? { ...item, targetKey: event.target.value } : item) })}
>
<option value="">Choose destination…</option>
{possibleTargets.map((target) => <option key={target.key} value={target.key}>{target.title || target.key}</option>)}
</select>
</div>
<button type="button" onClick={() => onRemovePath(transitionIndex)} className="min-h-[44px] min-w-[44px] inline-flex items-center justify-center mt-2 p-1 text-port-text-muted hover:text-port-error" aria-label={`Remove path ${transitionIndex + 1} from ${scene.title || scene.key}`}>
<Trash2 size={14} />
</button>
</div>
))}
</div>
)}
</div>
) : null}
</article>
);
}
export default function LoomEpisodeOutlinePlanner({
open,
loom,
episode,
guidance = '',
disabled = false,
onLoomUpdate,
onExpand,
expanding = false,
}) {
const [outline, setOutline] = useState(() => cloneOutline(episode.storyOutline));
const [dirty, setDirty] = useState(false);
const [validation, setValidation] = useState(null);
const [review, setReview] = useState(null);
const [shotPlanning, setShotPlanning] = useState(false);
const [expandedKey, setExpandedKey] = useState(null);
const [route, setRoute] = useState({ providerId: '', model: '', effort: '' });
const generateRun = useFableLoomAiRun();
const reviewRun = useFableLoomAiRun();
const { providers, loading: providersLoading } = useProviderModels({
allowDefault: true, silent: true, withEffort: true, enabled: open,
});
const selectedProvider = providers.find((provider) => provider.id === route.providerId);
const routeBody = useMemo(() => ({
...(route.providerId ? { providerId: route.providerId } : {}),
...(route.model ? { model: route.model } : {}),
...(route.effort ? { effort: route.effort } : {}),
}), [route]);
useEffect(() => {
setOutline(cloneOutline(episode.storyOutline));
setDirty(false);
setValidation(null);
setReview(null);
setExpandedKey(null);
}, [episode.id]);
const scenes = asArray(outline?.scenes);
const plotPoints = asArray(loom.seriesPlan?.plotPoints)
.filter((item) => item.episodeId === episode.id);
const outlineStatus = validation?.stats
? (validation.stats.errorCount ? 'invalid' : 'valid')
: outline?.validation?.status || 'draft';
const busy = shotPlanning || disabled || providersLoading || generateRun.run?.phase === 'running' || reviewRun.run?.phase === 'running';
const hasScenes = episode.nodes.length > 0;
const activeValidation = validation || outline?.validation;
const activeValidationIssues = asArray(activeValidation?.issues);
const replacementBlockingIssues = activeValidationIssues
.filter((issue) => issue.severity !== 'warning');
const teleplayReplacementReady = hasScenes
&& outlineStatus === 'invalid'
&& replacementBlockingIssues.length > 0
&& replacementBlockingIssues.every(isTeleplaySyncIssue);
const canExpand = outlineStatus === 'valid' || teleplayReplacementReady;
const updateOutline = (updater) => {
setOutline((current) => {
if (!current) return current;
const next = typeof updater === 'function' ? updater(current) : updater;
return { ...next, validation: { ...draftValidation } };
});
setDirty(true);
setValidation(null);
setReview(null);
};
const updateBeat = (key, patch) => updateOutline((current) => ({
...current,
scenes: current.scenes.map((scene) => scene.key === key ? { ...scene, ...patch } : scene),
}));
const [generateOutline, generating] = useAsyncAction(async () => {
const operationId = generateRun.begin();
const result = await generateLoomEpisodeOutline(loom.id, episode.id, {
...routeBody,
...(guidance.trim() ? { guidance: guidance.trim() } : {}),
operationId,
}, { silent: true }).catch((error) => {
generateRun.fail(error.message);
throw error;
});
const next = cloneOutline(result.outline || result.loom?.episodes?.find((item) => item.id === episode.id)?.storyOutline);
setOutline(next);
setValidation(result.validation || null);
setReview(null);
setDirty(false);
onLoomUpdate(result.loom);
toast.success(hasScenes ? 'Beat outline refreshed from the episode' : 'Episode beat outline drafted');
}, { errorMessage: 'Episode outline drafting failed' });
const [saveOutline, saving] = useAsyncAction(async () => {
if (!outline) return;
const updated = await updateLoomEpisode(loom.id, episode.id, {
storyOutline: { ...outline, validation: { ...draftValidation } },
}, { silent: true });
onLoomUpdate(updated);
const saved = updated.episodes.find((item) => item.id === episode.id)?.storyOutline;
setOutline(cloneOutline(saved));
setDirty(false);
setValidation(null);
setReview(null);
toast.success('Beat outline saved');
return updated;
}, { errorMessage: 'Could not save episode outline' });
const [validateOutline, validating] = useAsyncAction(async () => {
if (dirty) {
const saved = await saveOutline();
if (!saved) return;
}
const result = await validateLoomEpisodeOutline(loom.id, episode.id, { silent: true });
setOutline(cloneOutline(result.outline));
setValidation(result.validation);
setDirty(false);
onLoomUpdate(result.loom);
toast.success(result.validation.stats.errorCount ? 'Outline needs edits' : 'Outline validated — ready for expansion');
}, { errorMessage: 'Outline validation failed' });
const [reviewOutline, reviewing] = useAsyncAction(async () => {
if (dirty) return;
const operationId = reviewRun.begin();
const result = await reviewLoomEpisodeOutline(loom.id, episode.id, { ...routeBody, operationId }, { silent: true })
.catch((error) => { reviewRun.fail(error.message); throw error; });
setReview(result.analysis);
if (result.structural) setValidation(result.structural);
}, { errorMessage: 'Episode outline review failed' });
return (
<section className="space-y-3 border-t border-port-border pt-4" aria-label="Episode story outline planner">
<div>
<h4 className="flex items-center gap-1.5 text-sm font-semibold"><Sparkles size={14} className="text-port-accent" /> Story beats → teleplay</h4>
<p className="mt-1 text-xs text-port-text-muted">
Plan the complete episode as log-lines first. Review and validate the arc before expanding it into full scene text, choices, and media prompts.
</p>
</div>
<ProviderModelSelector
providers={providers}
selectedProviderId={route.providerId}
selectedModel={route.model}
availableModels={effortAwareModelOptions(selectedProvider, route.model)}
onProviderChange={(providerId) => setRoute({ providerId, model: '', effort: '' })}
onModelChange={(model) => setRoute((current) => ({ ...current, model }))}
effort={route.effort}
onEffortChange={(effort) => setRoute((current) => ({ ...current, effort }))}
label="Outline AI route"
layout="stacked"
disabled={busy || generating || saving || validating || reviewing || expanding}
modelDisabled={busy || generating || saving || validating || reviewing || expanding}
loading={providersLoading}
emptyProviderOption="Default (outline stage or active provider)"
emptyModelOption="Default model"
alwaysShowModel={!!route.providerId}
/>
{selectedProvider ? <p className="text-xs text-port-text-muted">Uses {selectedProvider.name}{effectiveModelFor(selectedProvider, route.model) ? ` (${effectiveModelFor(selectedProvider, route.model)})` : ''}{route.effort ? ` at ${route.effort} effort` : ''} for outline and expansion actions.</p> : null}
{!outline ? (
<button
type="button"
onClick={generateOutline}
disabled={busy || generating || saving || validating || reviewing || expanding}
className="flex w-full items-center justify-center gap-2 rounded bg-port-accent px-3 py-2 text-sm text-white disabled:opacity-50"
>
{generating ? <Loader2 size={14} className="animate-spin" /> : <Sparkles size={14} />}
{generating ? 'Drafting beat outline…' : hasScenes ? 'Draft outline from current teleplay' : 'Draft story beat outline'}
</button>
) : (
<>
<div className="flex items-center justify-between gap-2 text-xs text-port-text-muted">
<span>{scenes.length} beat{scenes.length === 1 ? '' : 's'} · {scenes.filter((scene) => scene.isEnding).length} ending{scenes.filter((scene) => scene.isEnding).length === 1 ? '' : 's'} · {outlineStatus}</span>
<button type="button" onClick={generateOutline} disabled={busy || generating || saving || validating || reviewing || expanding} className="text-port-accent hover:underline disabled:opacity-50">
{generating ? 'Refreshing…' : 'Refresh with AI'}
</button>
</div>
<div className="max-h-[42vh] space-y-2 overflow-y-auto pr-1">
{scenes.map((scene, index) => (
<OutlineBeat
key={scene.key}
scene={scene}
index={index}
scenes={scenes}
plotPoints={plotPoints}
expanded={expandedKey === scene.key}
onToggle={() => setExpandedKey((current) => current === scene.key ? null : scene.key)}
onChange={(patch) => updateBeat(scene.key, patch)}
onRemovePath={(transitionIndex) => updateBeat(scene.key, {
transitions: asArray(scene.transitions).filter((_, pathIndex) => pathIndex !== transitionIndex),
})}
onAddPath={() => updateBeat(scene.key, {
transitions: [...asArray(scene.transitions), { targetKey: '', intent: '' }],
})}
/>
))}
</div>
<div className="flex flex-wrap gap-2">
<button type="button" onClick={saveOutline} disabled={!dirty || busy || saving || generating || validating || reviewing || expanding} className="flex items-center gap-1.5 rounded border border-port-border px-3 py-2 text-xs hover:border-port-accent disabled:opacity-50">
{saving ? <Loader2 size={13} className="animate-spin" /> : <Save size={13} />}
{saving ? 'Saving…' : 'Save outline'}
</button>
<button type="button" onClick={validateOutline} disabled={busy || saving || generating || validating || reviewing || expanding} className="flex items-center gap-1.5 rounded border border-port-accent px-3 py-2 text-xs text-port-accent hover:bg-port-accent/10 disabled:opacity-50">
{validating ? <Loader2 size={13} className="animate-spin" /> : <CheckCircle2 size={13} />}
{validating ? 'Validating…' : dirty ? 'Save & validate' : 'Validate outline'}
</button>
<button type="button" onClick={reviewOutline} disabled={busy || dirty || saving || generating || validating || reviewing || expanding} className="flex items-center gap-1.5 rounded border border-port-border px-3 py-2 text-xs hover:border-port-accent disabled:opacity-50">
{reviewing ? <Loader2 size={13} className="animate-spin" /> : <Sparkles size={13} />}
{reviewing ? 'Reviewing…' : 'Review arc with AI'}
</button>
</div>
{dirty ? <p className="text-xs text-port-warning">Save the edited log-lines before asking the AI to review them.</p> : null}
<ValidationResult
validation={activeValidation}
teleplayReplacementReady={teleplayReplacementReady}
/>
{onExpand ? (
<button
type="button"
onClick={() => onExpand(routeBody)}
disabled={busy || dirty || !canExpand || saving || generating || validating || reviewing || expanding}
className="flex w-full items-center justify-center gap-2 rounded bg-port-accent px-3 py-2 text-sm text-white disabled:opacity-50"
>
{expanding ? <Loader2 size={14} className="animate-spin" /> : <Sparkles size={14} />}
{expanding
? 'Expanding validated outline…'
: teleplayReplacementReady
? 'Replace old teleplay from this outline'
: 'Expand validated outline to teleplay'}
</button>
) : null}
{review ? (
<div className="space-y-2 rounded border border-port-accent/30 bg-port-bg p-3" aria-live="polite">
<h5 className="text-sm font-semibold">Editorial outline review</h5>
{review.summary ? <p className="text-xs text-port-text-muted">{review.summary}</p> : null}
{[
['Strengths', review.strengths],
['Story risks', review.risks],
['Recommended edits', review.recommendations],
].map(([heading, items]) => items?.length ? <div key={heading}>
<h6 className="text-[11px] font-semibold uppercase tracking-wide text-port-text-muted">{heading}</h6>
<ul className="mt-1 list-disc space-y-1 pl-4 text-xs">{items.map((item) => <li key={item}>{item}</li>)}</ul>
</div> : null)}
</div>
) : null}
</>
)}
<LoomShotPlanner onRunningChange={setShotPlanning} key={episode.id} loom={loom} episode={episode} route={routeBody} guidance={guidance} disabled={busy || dirty || generating || saving || validating || reviewing || expanding} onLoomUpdate={(next) => { onLoomUpdate(next); setOutline(cloneOutline(next.episodes.find((item) => item.id === episode.id)?.storyOutline)); setValidation(null); }} />
<LoomAiRunStatus run={generateRun.run} />
<LoomAiRunStatus run={reviewRun.run} />
</section>
);
}