Skip to content

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

21.6 KB
Raw Blame
import { useEffect, useMemo, useRef, useState } from 'react';
import { Link } from 'react-router';
import {
  AlertTriangle, BrainCircuit, CheckCircle2, Loader2, Sparkles, Square, Waypoints,
} from 'lucide-react';
import ProviderModelSelector from '../ProviderModelSelector';
import toast from '../ui/Toast';
import { useAsyncAction } from '../../hooks/useAsyncAction';
import { useFableLoomRun } from '../../hooks/useFableLoomRun';
import useFableLoomAiRun from '../../hooks/useFableLoomAiRun';
import useProviderModels from '../../hooks/useProviderModels';
import {
  cancelLoomEditorialAutopilot,
  getLoom,
  getLoomEditorialAutopilotStatus,
  remediateLoomEditorial,
  reviewLoomPlaythroughs,
  startLoomEditorialAutopilot,
} from '../../services/api';
import { effectiveModelFor, effortAwareModelOptions } from '../../utils/providers';
import LoomAiRunStatus from './LoomAiRunStatus';

const ACTIVE_STATUSES = new Set(['running', 'canceling']);

const routePayload = (route) => ({
  ...(route.providerId ? { providerId: route.providerId } : {}),
  ...(route.model ? { model: route.model } : {}),
  ...(route.effort ? { effort: route.effort } : {}),
});

const statusClass = (status) => {
  if (status === 'completed') return 'border-port-success/40 bg-port-success/5 text-port-success';
  if (status === 'failed') return 'border-port-error/40 bg-port-error/5 text-port-error';
  if (status === 'paused' || status === 'canceled') return 'border-port-warning/40 bg-port-warning/5 text-port-warning';
  return 'border-port-accent/30 bg-port-accent/5 text-port-accent';
};

function Metric({ label, value, tone = 'default' }) {
  const valueClass = tone === 'good'
    ? 'text-port-success'
    : tone === 'bad' ? 'text-port-error' : 'text-port-text';
  return (
    <div className="rounded border border-port-border bg-port-bg/40 px-3 py-2">
      <p className="text-[11px] text-port-text-muted">{label}</p>
      <p className={`mt-0.5 text-sm font-semibold ${valueClass}`}>{value}</p>
    </div>
  );
}

function FindingLink({ loom, finding }) {
  const episode = loom.episodes.find((candidate) => candidate.id === finding.episodeId);
  const scene = episode?.nodes?.find((candidate) => candidate.id === finding.nodeId);
  const target = episode
    ? `/fableloom/${encodeURIComponent(loom.id)}/${encodeURIComponent(episode.id)}${scene ? `/${encodeURIComponent(scene.id)}` : ''}`
    : null;
  const severity = finding.severity === 'error' ? 'high' : finding.severity;
  const Icon = severity === 'high' ? AlertTriangle : Waypoints;
  return (
    <li className="rounded border border-port-border px-3 py-2 text-xs">
      <div className="flex items-start gap-2">
        <Icon
          size={13}
          className={`mt-0.5 shrink-0 ${severity === 'high' ? 'text-port-error' : 'text-port-warning'}`}
        />
        <div className="min-w-0 flex-1">
          <p>{finding.problem || finding.message}</p>
          {finding.suggestion ? <p className="mt-1 text-port-text-muted">{finding.suggestion}</p> : null}
          {target ? (
            <Link to={target} className="mt-1 inline-block text-port-accent hover:underline">
              Episode {episode.number || loom.episodes.indexOf(episode) + 1}{scene ? ` · ${scene.title || 'Scene'}` : ''}
            </Link>
          ) : null}
        </div>
      </div>
    </li>
  );
}

/** Whole-series one-pass editor, bounded editor/reviewer autopilot, and playthrough QA. */
export default function LoomEditorialAutomation({ loom, dirty, onLoomUpdate }) {
  const [route, setRoute] = useState({ providerId: '', model: '', effort: '' });
  const [mode, setMode] = useState(() => loom.episodes.some((episode) => episode.nodes?.length) ? 'series' : 'planning');
  const [maxRounds, setMaxRounds] = useState(3);
  const [selfImprove, setSelfImprove] = useState(false);
  const [result, setResult] = useState(null);
  const loomIdentityRef = useRef(loom.id);
  loomIdentityRef.current = loom.id;
  const { run: autopilotRun, applyRun: setAutopilotRun } = useFableLoomRun({
    loomId: loom.id,
    event: 'fableloom:editorial:run',
    loadRun: () => getLoomEditorialAutopilotStatus(loom.id, { silent: true }).then(response => response.run),
    onTerminal: (run, isCurrent) => {
      setResult({ type: 'autopilot', run });
      getLoom(loom.id, { silent: true }).then(updated => {
        if (isCurrent()) onLoomUpdate(updated);
      }).catch(() => {});
    },
  });
  const remediationAi = useFableLoomAiRun();
  const playtestAi = useFableLoomAiRun();
  const { providers, activeProviderId, loading: providersLoading } = useProviderModels({
    allowDefault: true,
    silent: true,
    withEffort: true,
  });
  const effectiveProviderId = route.providerId || activeProviderId;
  const selectedProvider = providers.find((provider) => provider.id === effectiveProviderId);
  const selectedModel = effectiveModelFor(selectedProvider, route.model);
  const routeBody = useMemo(() => routePayload(route), [route]);

  useEffect(() => { setResult(null); }, [loom.id]);

  const autopilotActive = ACTIVE_STATUSES.has(autopilotRun?.status);
  useEffect(() => {
    if (!ACTIVE_STATUSES.has(autopilotRun?.status)) return;
    setResult(null);
    setRoute({ providerId: autopilotRun.route?.providerId || '', model: autopilotRun.route?.model || '', effort: autopilotRun.route?.effort || '' });
    setMode(autopilotRun.mode || 'series');
    setMaxRounds(autopilotRun.maxRounds);
    setSelfImprove(autopilotRun.selfImproveEnabled === true);
  }, [autopilotRun?.id]);

  const [remediate, remediating] = useAsyncAction(async () => {
    const operationId = remediationAi.begin();
    const response = await remediateLoomEditorial(loom.id, {
      ...routeBody,
      operationId,
    }, { silent: true }).catch((error) => {
      remediationAi.fail(error.message);
      throw error;
    });
    setResult({ type: 'remediation', response });
    onLoomUpdate(response.loom);
    toast.success(response.changed
      ? `Series remediated — ${response.changes.length || 1} safe edit${response.changes.length === 1 ? '' : 's'} applied`
      : 'Series evaluated — no safe edit was needed');
  }, { errorMessage: 'Series editorial remediation failed' });

  const [runPlaytest, playtesting] = useAsyncAction(async () => {
    const operationId = playtestAi.begin();
    const response = await reviewLoomPlaythroughs(loom.id, {
      ...routeBody,
      aiReview: true,
      operationId,
    }, { silent: true }).catch((error) => {
      playtestAi.fail(error.message);
      throw error;
    });
    setResult({ type: 'playtest', response });
    toast.success(response.passed
      ? 'Every enumerated playthrough passed structural and narrative review'
      : 'Playthrough review found issues to resolve');
  }, { errorMessage: 'Playthrough test failed' });

  const [startAutopilot, startingAutopilot] = useAsyncAction(async () => {
    const run = await startLoomEditorialAutopilot(loom.id, {
      ...routeBody,
      maxRounds,
      ...(mode === 'planning' ? { mode } : {}),
      ...(selfImprove ? { selfImprove: true } : {}),
    }, { silent: true });
    if (loomIdentityRef.current !== loom.id) return;
    setResult(null);
    setAutopilotRun(run);
    toast.success(run.alreadyRunning ? 'Reattached to the active editorial autopilot' : 'Editorial autopilot started');
  }, { errorMessage: 'Could not start editorial autopilot' });

  const [cancelAutopilot, cancelingAutopilot] = useAsyncAction(async () => {
    const run = await cancelLoomEditorialAutopilot(loom.id, autopilotRun.id, { silent: true });
    setAutopilotRun(run);
  }, { errorMessage: 'Could not cancel editorial autopilot' });

  const busy = remediating || playtesting || startingAutopilot || cancelingAutopilot || autopilotActive;
  const blocked = dirty || !loom.episodes.length;
  const response = result?.response;
  const shownRun = autopilotActive || result?.type === 'autopilot' ? autopilotRun : result ? null : autopilotRun;
  const diagnostics = result?.type === 'remediation' ? response?.diagnostics : null;
  const deterministic = result?.type === 'playtest'
    ? response?.deterministic
    : diagnostics?.playthrough || shownRun?.lastPlaytest;
  const stats = deterministic?.stats;
  const remediationStats = result?.type === 'remediation'
    ? response?.after
    : shownRun?.rounds?.at(-1)?.after;
  const review = result?.type === 'playtest' ? response?.review : shownRun?.lastReview;
  const evaluation = result?.type === 'remediation' ? response?.evaluation : shownRun?.lastEvaluation;
  const findings = result?.type === 'autopilot' || shownRun?.status
    ? shownRun?.residualFindings || []
    : review?.findings?.length ? review.findings : evaluation?.findings || [];
  const summary = shownRun?.message || review?.summary || evaluation?.summary;
  const passed = result?.type === 'playtest'
    ? response?.passed
    : shownRun?.status === 'completed' || diagnostics?.passed;
  const resultHeading = passed
    ? (shownRun?.mode === 'planning' ? 'Series planning is ready for scene expansion' : 'Series clears the current editorial gates')
    : shownRun?.status === 'failed'
      ? 'Editorial automation needs attention'
      : shownRun?.status === 'canceled'
        ? 'Editorial autopilot stopped'
        : 'Editorial work remains';
  const restartLabel = ['failed', 'paused', 'canceled'].includes(shownRun?.status)
    ? 'Retry editor autopilot'
    : 'Start editor autopilot';

  return (
    <section
      className="rounded-lg border border-port-accent/40 bg-port-card p-4 space-y-4"
      aria-label="AI editorial automation"
    >
      <div className="flex flex-col gap-2 sm:flex-row sm:items-start sm:justify-between">
        <div>
          <h3 className="font-semibold flex items-center gap-2">
            <BrainCircuit size={16} className="text-port-accent" /> AI editor, reviewer & playtest
          </h3>
          <p className="mt-1 text-xs text-port-text-muted max-w-3xl">
            {mode === 'planning'
              ? 'Review the series arc and challenges, then draft and check each episode’s camera-cut outline. Resolve planning problems before writing the teleplay or generating media.'
              : 'Evaluate and repair the complete teleplay, then independently review every enumerated gameplay path. Autopilot repeats until the story passes or reaches its round limit.'}
          </p>
        </div>
        {shownRun ? (
          <span className={`shrink-0 rounded border px-2 py-1 text-xs ${statusClass(shownRun.status)}`}>
            {shownRun.status}
            {shownRun.stepIndex ? ` · step ${shownRun.stepIndex}/${shownRun.stepCount}` : ''}
            {` · round ${shownRun.round}/${shownRun.maxRounds}`}
          </span>
        ) : null}
      </div>

      <div>
        <label htmlFor="fableloom-autopilot-mode" className="block text-xs text-port-text-muted mb-1">Autopilot stage</label>
        <select id="fableloom-autopilot-mode" value={mode} onChange={(event) => setMode(event.target.value)} disabled={busy} className="w-full min-h-11 rounded border border-port-border bg-port-bg px-3 text-sm">
          <option value="planning">Plan the series before writing scenes</option>
          <option value="series">Edit and playtest the complete teleplay</option>
        </select>
        <p className="mt-1 text-xs text-port-text-muted">Planning reviews the arc first, then drafts and reviews each episode outline in order. It stops before scene expansion or media generation.</p>
      </div>
      <div className="grid gap-3 lg:grid-cols-[minmax(0,1fr)_9rem]">
        <ProviderModelSelector
          providers={providers}
          selectedProviderId={route.providerId}
          effectiveProviderId={effectiveProviderId}
          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="Editorial AI route"
          disabled={busy || providersLoading}
          modelDisabled={busy || providersLoading}
          loading={providersLoading}
          emptyProviderOption="Default (editorial stage or active provider)"
          emptyModelOption="Default model"
          alwaysShowModel={!!route.providerId}
        />
        <div>
          <label htmlFor="fableloom-editorial-rounds" className="block text-xs text-gray-500 mb-1">
            Autopilot rounds
          </label>
          <select
            id="fableloom-editorial-rounds"
            value={maxRounds}
            onChange={(event) => setMaxRounds(Number(event.target.value))}
            disabled={busy}
            className="w-full px-3 py-1.5 min-h-[36px] bg-port-bg border border-port-border rounded-lg text-white text-sm"
          >
            {[1, 2, 3, 4, 5, 6].map((rounds) => (
              <option key={rounds} value={rounds}>{rounds}</option>
            ))}
          </select>
        </div>
      </div>
      {selectedProvider ? (
        <p className="text-xs text-port-text-muted">
          Runs will use {selectedProvider.name}{selectedModel ? ` (${selectedModel})` : ''}
          {route.effort ? ` at ${route.effort} effort` : ' at the provider default effort'}.
        </p>
      ) : null}

      <div className="rounded border border-port-border bg-port-bg/30 px-3 py-2">
        <label htmlFor="fableloom-editorial-self-improve" className="flex items-start gap-2 text-xs text-port-text">
          <input
            id="fableloom-editorial-self-improve"
            type="checkbox"
            checked={selfImprove}
            onChange={(event) => setSelfImprove(event.target.checked)}
            disabled={busy}
            className="mt-0.5"
          />
          <span>
            <span className="font-medium">Improve FableLoom itself when autopilot stalls or fails</span>
            <span className="mt-1 block text-[11px] text-port-text-muted">
              Runs one content-free, budget-gated post-mortem to distinguish story work from a broken or inefficient editor/reviewer workflow. A confident PortOS defect queues a deduplicated worktree + PR CoS task in the approval queue; it never starts by itself. Healthy and canceled runs spend nothing.
            </span>
          </span>
        </label>
      </div>

      <div className="grid gap-2 sm:grid-cols-3">
        <button
          type="button"
          onClick={remediate}
          disabled={blocked || busy}
          className="flex min-h-11 items-center justify-center gap-2 rounded bg-port-accent px-3 py-2 text-sm font-medium text-white disabled:opacity-50"
        >
          {remediating ? <Loader2 size={14} className="animate-spin" /> : <Sparkles size={14} />}
          {remediating ? 'Remediating…' : 'Evaluate & remediate series'}
        </button>
        <button
          type="button"
          onClick={runPlaytest}
          disabled={blocked || busy}
          className="flex min-h-11 items-center justify-center gap-2 rounded border border-port-accent px-3 py-2 text-sm text-port-accent hover:bg-port-accent/10 disabled:opacity-50"
        >
          {playtesting ? <Loader2 size={14} className="animate-spin" /> : <Waypoints size={14} />}
          {playtesting ? 'Testing paths…' : 'Run playthrough test'}
        </button>
        {autopilotActive ? (
          <button
            type="button"
            onClick={cancelAutopilot}
            disabled={cancelingAutopilot || autopilotRun.status === 'canceling'}
            className="flex min-h-11 items-center justify-center gap-2 rounded border border-port-warning px-3 py-2 text-sm text-port-warning disabled:opacity-50"
          >
            {cancelingAutopilot ? <Loader2 size={14} className="animate-spin" /> : <Square size={13} />}
            {autopilotRun.status === 'canceling' ? 'Canceling after this step…' : 'Stop editor autopilot'}
          </button>
        ) : (
          <button
            type="button"
            onClick={startAutopilot}
            disabled={blocked || busy}
            className="flex min-h-11 items-center justify-center gap-2 rounded border border-port-accent px-3 py-2 text-sm text-port-accent hover:bg-port-accent/10 disabled:opacity-50"
          >
            {startingAutopilot ? <Loader2 size={14} className="animate-spin" /> : <BrainCircuit size={14} />}
            {startingAutopilot ? 'Starting…' : restartLabel}
          </button>
        )}
      </div>

      {dirty ? (
        <p className="text-xs text-port-warning" role="status">Save the current series-plan edits before running editorial automation.</p>
      ) : !loom.episodes.length ? (
        <p className="text-xs text-port-warning" role="status">Add at least one episode before running editorial automation.</p>
      ) : null}
      {autopilotActive ? (
        <div className="flex items-center gap-2 rounded border border-port-accent/30 bg-port-accent/5 px-3 py-2 text-xs text-port-text-muted" role="status">
          <Loader2 size={14} className="animate-spin text-port-accent" />
          <span>{autopilotRun.message}</span>
        </div>
      ) : null}
      <LoomAiRunStatus run={remediationAi.run} />
      <LoomAiRunStatus run={playtestAi.run} />

      {(stats || remediationStats || review || evaluation || shownRun) ? (
        <div className="space-y-3 border-t border-port-border pt-4" aria-label="Editorial automation results">
          <div className="flex items-start gap-2">
            {passed ? (
              <CheckCircle2 size={16} className="mt-0.5 shrink-0 text-port-success" />
            ) : (
              <AlertTriangle size={16} className="mt-0.5 shrink-0 text-port-warning" />
            )}
            <div>
              <p className="text-sm font-medium">
                {resultHeading}
              </p>
              {summary ? <p className="mt-1 text-xs text-port-text-muted">{summary}</p> : null}
            </div>
          </div>
          <div className="grid grid-cols-2 gap-2 md:grid-cols-5">
            {remediationStats ? (
              <>
                <Metric label="Outline blockers" value={remediationStats.outlineErrors} tone={remediationStats.outlineErrors ? 'bad' : 'good'} />
                <Metric label="Graph blockers" value={remediationStats.graphErrors} tone={remediationStats.graphErrors ? 'bad' : 'good'} />
                <Metric label="Convergence gaps" value={remediationStats.convergenceIssues} tone={remediationStats.convergenceIssues ? 'bad' : 'good'} />
              </>
            ) : null}
            {stats ? (
              <>
                <Metric label="Variations tested" value={stats.variationCount} />
                <Metric
                  label="Path coverage"
                  value={`${stats.visitedTransitionCount}/${stats.transitionCount}`}
                  tone={stats.visitedTransitionCount === stats.transitionCount ? 'good' : 'bad'}
                />
              </>
            ) : null}
            {review?.qualityScore != null ? (
              <Metric label="Story quality" value={`${review.qualityScore}/10`} tone={review.qualityScore >= 8 ? 'good' : 'bad'} />
            ) : null}
          </div>
          {evaluation?.strengths?.length || review?.strengths?.length ? (
            <p className="text-xs text-port-text-muted">
              <span className="font-medium text-port-text">Strengths:</span>{' '}
              {(review?.strengths?.length ? review.strengths : evaluation.strengths).join(' · ')}
            </p>
          ) : null}
          {findings.length ? (
            <ul className="space-y-2">
              {findings.slice(0, 12).map((finding, index) => (
                <FindingLink
                  key={`${finding.episodeId || 'series'}-${finding.nodeId || finding.pathId || index}-${index}`}
                  loom={loom}
                  finding={finding}
                />
              ))}
            </ul>
          ) : null}
          {shownRun?.rounds?.length ? (
            <p className="text-[11px] text-port-text-muted">
              {shownRun.rounds.length} bounded editorial round{shownRun.rounds.length === 1 ? '' : 's'} recorded. The run stops on success, plateau, cancellation, provider failure, or the selected round limit.
            </p>
          ) : null}
          {shownRun?.invalidResponses ? (
            <p className="text-[11px] text-port-text-muted">
              {shownRun.status === 'failed'
                ? `Autopilot safely rejected ${shownRun.invalidResponses} invalid editor responses; no invalid changes were applied.`
                : `Autopilot safely rejected and retried ${shownRun.invalidResponses} invalid editor response${shownRun.invalidResponses === 1 ? '' : 's'} before continuing.`}
            </p>
          ) : null}
          {shownRun?.selfImprove?.verdict === 'pipeline' ? (
            <div className="rounded border border-port-accent/30 bg-port-accent/5 px-3 py-2 text-xs text-port-accent">
              <p>
                {shownRun.selfImprove.duplicate
                  ? `FableLoom improvement already tracked (${shownRun.selfImprove.area}): ${shownRun.selfImprove.title}`
                  : shownRun.selfImprove.filed
                    ? `Queued a FableLoom improvement (${shownRun.selfImprove.area}): ${shownRun.selfImprove.title}`
                    : `Diagnosed a FableLoom workflow defect (${shownRun.selfImprove.area}), but task filing failed: ${shownRun.selfImprove.title}`}
              </p>
              {shownRun.selfImprove.taskId ? (
                <Link
                  to={`/cos/tasks?task=${encodeURIComponent(shownRun.selfImprove.taskId)}&source=internal`}
                  className="mt-1 inline-block font-medium hover:underline"
                >
                  Review CoS task
                </Link>
              ) : null}
            </div>
          ) : null}
        </div>
      ) : null}
    </section>
  );
}