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 { beforeEach, describe, expect, it, vi } from 'vitest';
import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { createMemoryRouter, RouterProvider } from 'react-router';
import { useState } from 'react';
vi.mock('../../services/api', () => ({
feedbackLoomSeriesPlan: vi.fn(),
generateLoomSeriesPlan: vi.fn(),
reviewLoomSeriesPlan: vi.fn(),
reviewLoomTeleplay: vi.fn(),
updateLoom: vi.fn(),
validateLoomSeriesOutlines: vi.fn(),
}));
vi.mock('../../hooks/useProviderModels', () => ({ default: () => ({ providers: [], loading: false }) }));
vi.mock('../../services/socket', () => ({
default: { on: vi.fn(), off: vi.fn() },
}));
vi.mock('../ProviderModelSelector', () => ({ default: () => <div>AI route picker</div> }));
vi.mock('./LoomEditorialAutomation', () => ({
default: () => <div>Editorial automation</div>,
}));
import * as api from '../../services/api';
import LoomSeriesPlan from './LoomSeriesPlan';
const loom = (fields = {}) => ({
id: 'loom-1',
name: 'Example Loom',
episodes: [{ id: 'ep-1', number: 1, title: 'Pilot' }],
seriesPlan: {
storyArc: 'An old arc.',
plotPoints: [{ id: 'plot-1', title: 'The turn', description: 'Everything changes.', episodeId: 'ep-1' }],
sideQuests: [],
},
...fields,
});
beforeEach(() => {
vi.clearAllMocks();
});
const renderPlan = (props) => render(<RouterProvider router={createMemoryRouter([
{ path: '/', element: <LoomSeriesPlan {...props} /> },
], { initialEntries: ['/'] })} />);
function StatefulPlan({ initial }) {
const [record, setRecord] = useState(initial);
return <LoomSeriesPlan loom={record} onLoomUpdate={setRecord} />;
}
describe('LoomSeriesPlan', () => {
it('edits and saves the series-level plan as one patch', async () => {
const onLoomUpdate = vi.fn();
const updated = loom({ seriesPlan: { ...loom().seriesPlan, storyArc: 'A stronger arc.' } });
api.updateLoom.mockResolvedValue(updated);
renderPlan({ loom: loom(), onLoomUpdate });
fireEvent.change(screen.getByRole('textbox', { name: /story arc/i }), { target: { value: 'A stronger arc.' } });
fireEvent.click(screen.getByRole('tab', { name: 'AI editor' }));
fireEvent.click(screen.getByText('Manual AI plan tools'));
expect(screen.getByRole('button', { name: /analyze series/i })).toBeDisabled();
fireEvent.click(screen.getByRole('button', { name: /save plan/i }));
await waitFor(() => expect(api.updateLoom).toHaveBeenCalledWith('loom-1', {
seriesPlan: expect.objectContaining({ storyArc: 'A stronger arc.' }),
}, { silent: true }));
expect(onLoomUpdate).toHaveBeenCalledWith(updated);
});
it('authors and clears the shared series-design brief without adding it to legacy saves', async () => {
const user = userEvent.setup();
api.updateLoom.mockImplementation(async (_id, { seriesPlan }) => loom({ seriesPlan }));
render(<RouterProvider router={createMemoryRouter([
{ path: '/', element: <StatefulPlan initial={loom()} /> },
], { initialEntries: ['/'] })} />);
await user.selectOptions(screen.getByRole('combobox', { name: 'Story intent' }), 'renewable');
await user.type(screen.getByRole('textbox', { name: 'Episode activity' }), 'Decode a dangerous signal.');
await user.type(screen.getByRole('textbox', { name: 'Continuing tensions' }), 'Each relay hides another sender.');
await user.click(screen.getByRole('button', { name: /save plan/i }));
await waitFor(() => expect(api.updateLoom).toHaveBeenCalledTimes(1));
expect(api.updateLoom.mock.calls[0][1].seriesPlan.seriesDesign).toEqual(expect.objectContaining({
mode: 'renewable',
episodeActivity: 'Decode a dangerous signal.',
continuingTensions: 'Each relay hides another sender.',
}));
await user.selectOptions(screen.getByRole('combobox', { name: 'Story intent' }), '');
await user.click(screen.getByRole('button', { name: /save plan/i }));
await waitFor(() => expect(api.updateLoom).toHaveBeenCalledTimes(2));
expect(api.updateLoom.mock.calls[1][1].seriesPlan).not.toHaveProperty('seriesDesign');
});
it('adds a playable challenge as an episode-mapped plot-point contract', async () => {
const user = userEvent.setup();
api.updateLoom.mockResolvedValue(loom());
renderPlan({ loom: loom(), onLoomUpdate: vi.fn() });
await user.click(screen.getByRole('tab', { name: 'Plot & challenges' }));
await user.click(screen.getByRole('button', { name: 'Challenge' }));
const challengeTitle = screen.getByRole('textbox', { name: 'Plot points 2 title' });
expect(challengeTitle).toHaveValue('');
expect(challengeTitle).toHaveFocus();
expect(screen.getByRole('textbox', { name: 'Plot points 2 description' }).value)
.toContain('VIEWER DECISION LOOP');
expect(screen.getByText('0/1 playable challenges mapped to episodes')).toBeInTheDocument();
await user.selectOptions(within(challengeTitle.closest('details')).getByRole('combobox', { name: 'Episode' }), 'ep-1');
expect(screen.getByText('1/1 playable challenges mapped to episodes')).toBeInTheDocument();
});
it('keeps drafts across section changes and shows only the selected planning area', () => {
renderPlan({ loom: loom(), onLoomUpdate: vi.fn() });
fireEvent.change(screen.getByRole('textbox', { name: /story arc/i }), { target: { value: 'Unsaved arc' } });
fireEvent.click(screen.getByRole('tab', { name: 'Plot & challenges' }));
expect(screen.queryByRole('textbox', { name: /story arc/i })).not.toBeInTheDocument();
expect(screen.getByRole('heading', { name: 'Plot points' })).toBeVisible();
expect(screen.getByRole('button', { name: /save plan/i })).toBeVisible();
fireEvent.click(screen.getByRole('tab', { name: 'Story arc' }));
expect(screen.getByRole('textbox', { name: /story arc/i })).toHaveValue('Unsaved arc');
});
it('shows AI series analysis and recommendations for the outline', async () => {
api.reviewLoomSeriesPlan.mockResolvedValue({
analysis: {
summary: 'The spine works.',
strengths: ['Clear protagonist goal'],
risks: ['Midpoint arrives late'],
recommendations: ['Move the reversal into episode 3'],
},
});
renderPlan({ loom: loom(), onLoomUpdate: () => {} });
fireEvent.click(screen.getByRole('tab', { name: 'AI editor' }));
fireEvent.click(screen.getByText('Manual AI plan tools'));
fireEvent.click(screen.getByRole('button', { name: /analyze series/i }));
expect(await screen.findByText('The spine works.')).toBeInTheDocument();
expect(screen.getByText('Move the reversal into episode 3')).toBeInTheDocument();
});
it('applies AI editing feedback to revise the entire series outline and plot points', async () => {
const onLoomUpdate = vi.fn();
const updated = loom({
seriesPlan: {
storyArc: 'Revised arc.',
plotPoints: [{ id: 'plot-1', title: 'Moved turn', description: 'Changes earlier.', episodeId: 'ep-1' }],
sideQuests: [],
},
});
api.feedbackLoomSeriesPlan.mockResolvedValue({ loom: updated, changes: ['Shifted plot point turn'] });
renderPlan({ loom: loom(), onLoomUpdate });
fireEvent.click(screen.getByRole('tab', { name: 'AI editor' }));
fireEvent.click(screen.getByText('Manual AI plan tools'));
fireEvent.change(screen.getByRole('textbox', { name: /edit outline & plot points/i }), {
target: { value: 'Move the turn to episode 1 and raise stakes.' },
});
fireEvent.click(screen.getByRole('button', { name: /apply guidance to plan/i }));
await waitFor(() => expect(api.feedbackLoomSeriesPlan).toHaveBeenCalledWith(
'loom-1',
expect.objectContaining({
feedback: 'Move the turn to episode 1 and raise stakes.',
operationId: expect.any(String),
}),
{ silent: true },
));
expect(onLoomUpdate).toHaveBeenCalledWith(updated);
});
it('regenerates the whole saved scaffold through the selected AI route without touching episodes locally', async () => {
const onLoomUpdate = vi.fn();
const generated = loom({
seriesPlan: {
storyArc: 'A generated arc.',
plotPoints: [{ id: 'plot-new', title: 'New turn', description: 'The cost lands.', episodeId: 'ep-1' }],
sideQuests: [{ id: 'quest-new', title: 'Lost map', description: 'Find it.', status: 'planned', startEpisodeId: 'ep-1', endEpisodeId: null }],
},
});
api.generateLoomSeriesPlan.mockResolvedValue({ loom: generated, runId: 'run-draft' });
renderPlan({ loom: loom(), onLoomUpdate });
fireEvent.click(screen.getByRole('tab', { name: 'AI editor' }));
fireEvent.click(screen.getByText('Manual AI plan tools'));
fireEvent.click(screen.getByRole('button', { name: /regenerate full plan/i }));
expect(api.generateLoomSeriesPlan).not.toHaveBeenCalled();
fireEvent.click(screen.getByRole('button', { name: /^regenerate$/i }));
await waitFor(() => expect(api.generateLoomSeriesPlan).toHaveBeenCalledWith(
'loom-1', { operationId: expect.any(String) }, { silent: true },
));
expect(onLoomUpdate).toHaveBeenCalledWith(generated);
});
it('adopts a generated plan over typing performed while the provider call is in flight', async () => {
let finishDraft;
api.generateLoomSeriesPlan.mockImplementation(() => new Promise((resolve) => { finishDraft = resolve; }));
render(<RouterProvider router={createMemoryRouter([
{ path: '/', element: <StatefulPlan initial={loom()} /> },
], { initialEntries: ['/'] })} />);
fireEvent.click(screen.getByRole('tab', { name: 'AI editor' }));
fireEvent.click(screen.getByText('Manual AI plan tools'));
fireEvent.click(screen.getByRole('button', { name: /regenerate full plan/i }));
fireEvent.click(screen.getByRole('button', { name: /^regenerate$/i }));
fireEvent.click(screen.getByRole('tab', { name: 'Story arc' }));
fireEvent.change(screen.getByRole('textbox', { name: /story arc/i }), {
target: { value: 'Typing that should not undo the requested regeneration.' },
});
const generated = loom({ seriesPlan: {
storyArc: 'The generated arc wins.',
plotPoints: [],
sideQuests: [],
} });
finishDraft({ loom: generated, runId: 'run-draft' });
await waitFor(() => expect(screen.getByRole('textbox', { name: /story arc/i })).toHaveValue('The generated arc wins.'));
expect(screen.getByRole('button', { name: /save plan/i })).toBeDisabled();
});
it('keeps typing performed while a save response is in flight', async () => {
let resolveSave;
api.updateLoom.mockImplementation(() => new Promise((resolve) => { resolveSave = resolve; }));
render(<RouterProvider router={createMemoryRouter([
{ path: '/', element: <StatefulPlan initial={loom()} /> },
], { initialEntries: ['/'] })} />);
const arc = screen.getByRole('textbox', { name: /story arc/i });
fireEvent.change(arc, { target: { value: 'First draft.' } });
fireEvent.click(screen.getByRole('button', { name: /save plan/i }));
fireEvent.change(arc, { target: { value: 'Typed while saving.' } });
resolveSave(loom({ seriesPlan: { ...loom().seriesPlan, storyArc: 'First draft.' } }));
await waitFor(() => expect(screen.getByRole('textbox', { name: /story arc/i })).toHaveValue('Typed while saving.'));
expect(screen.getByRole('button', { name: /save plan/i })).toBeEnabled();
});
it('reviews the complete expanded teleplay only when every episode has scenes', async () => {
api.reviewLoomTeleplay.mockResolvedValue({
analysis: {
summary: 'The full teleplay escalates cleanly.',
strengths: ['The handoff is earned.'],
risks: [],
recommendations: [],
},
});
const fullLoom = loom({
episodes: [
{ id: 'ep-1', number: 1, title: 'Pilot', nodes: [{ id: 'node-1' }] },
{ id: 'ep-2', number: 2, title: 'Finale', nodes: [{ id: 'node-2' }] },
],
});
renderPlan({ loom: fullLoom, onLoomUpdate: () => {} });
fireEvent.click(screen.getByRole('tab', { name: 'AI editor' }));
fireEvent.click(screen.getByText('Manual AI plan tools'));
expect(screen.getByRole('button', { name: 'Review full teleplay' })).toBeEnabled();
await userEvent.setup().click(screen.getByRole('button', { name: 'Review full teleplay' }));
expect(await screen.findByText('The full teleplay escalates cleanly.')).toBeInTheDocument();
expect(api.reviewLoomTeleplay).toHaveBeenCalledWith('loom-1', { operationId: expect.any(String) }, { silent: true });
});
it('validates the complete ordered beat arc and links blocking issues to episodes', async () => {
api.validateLoomSeriesOutlines.mockResolvedValue({
stats: { ready: false, errorCount: 1 },
issues: [{ code: 'MISSING_EPISODE_OUTLINE', episodeId: 'ep-1', message: 'Draft Episode 1 first.' }],
});
const user = userEvent.setup();
renderPlan({ loom: loom(), onLoomUpdate: () => {} });
await user.click(screen.getByRole('tab', { name: 'Episode outlines' }));
await user.click(screen.getByRole('button', { name: 'Validate full beat arc' }));
expect(await screen.findByText(/Draft Episode 1 first\./)).toBeInTheDocument();
expect(screen.getByRole('link', { name: 'Episode 1' })).toHaveAttribute('href', '/fableloom/loom-1/ep-1');
expect(api.validateLoomSeriesOutlines).toHaveBeenCalledWith('loom-1', { silent: true });
});
it('authors configured overnight handoffs and a finale teaser in the series plan', async () => {
const user = userEvent.setup();
const threeEpisodeLoom = loom({
episodes: [
{ id: 'ep-1', number: 1, title: 'Pilot' },
{ id: 'ep-2', number: 2, title: 'The Turn' },
{ id: 'ep-3', number: 3, title: 'Finale' },
],
});
const onLoomUpdate = vi.fn();
renderPlan({ loom: threeEpisodeLoom, onLoomUpdate });
await user.click(screen.getByRole('tab', { name: 'Viewer handoffs' }));
await user.click(screen.getByLabelText(/overnight voicemail between episodes/i));
expect(screen.getAllByRole('textbox', { name: 'Voicemail transcript' })).toHaveLength(2);
await user.type(screen.getAllByRole('textbox', { name: 'Voicemail transcript' })[0], 'Stay awake. The beacon is listening.');
await user.click(screen.getByLabelText(/next-season teaser after the finale/i));
await user.type(screen.getByRole('textbox', { name: 'Teaser / cliffhanger' }), 'Something answers from beyond the relay.');
await user.click(screen.getByRole('button', { name: /save plan/i }));
await waitFor(() => expect(api.updateLoom).toHaveBeenCalledWith(
'loom-1',
expect.objectContaining({
seriesPlan: expect.objectContaining({
deliveryOptions: { overnightVoicemails: true, nextSeasonTeaser: true },
interEpisodeVoicemails: expect.arrayContaining([
expect.objectContaining({
fromEpisodeId: 'ep-1', toEpisodeId: 'ep-2',
transcript: 'Stay awake. The beacon is listening.',
}),
]),
nextSeasonTeaser: expect.objectContaining({
transcript: 'Something answers from beyond the relay.',
}),
}),
}),
{ silent: true },
));
});
});
// The OPTIONAL five-stage character evolution lens (#6441). Its own fixture so
// the outline-scene keys and linked cast this section needs stay out of the
// plan fixture every other test shares.
const castLoom = (plan = {}) => ({
id: 'loom-1',
name: 'Example Loom',
episodes: [
{ id: 'ep-1', number: 1, title: 'Pilot', storyOutline: { scenes: [{ key: 'the-blockade' }] } },
{ id: 'ep-2', number: 2, title: 'Finale', storyOutline: { scenes: [{ key: 'the-cost' }] } },
],
seriesPlan: { storyArc: 'An old arc.', plotPoints: [], sideQuests: [], ...plan },
});
const castUniverse = {
id: 'uni-1',
characters: [
{
id: 'chr-1111',
name: 'Vale',
psychology: { theoryOfControl: 'If I stay useful, nobody leaves.' },
},
{ id: 'chr-2222', name: 'Roan' },
],
};
const renderCastPlan = (props, entry = '/?section=cast') => render(<RouterProvider router={createMemoryRouter([
{ path: '/', element: <LoomSeriesPlan universe={castUniverse} onLoomUpdate={vi.fn()} {...props} /> },
], { initialEntries: [entry] })} />);
const savedPlan = () => api.updateLoom.mock.calls.at(-1)[1].seriesPlan;
describe('LoomSeriesPlan — cast evolution lens', () => {
it('deep-links straight to the cast section and offers the linked universe cast', () => {
renderCastPlan({ loom: castLoom() });
expect(screen.getByRole('heading', { name: 'Cast evolution' })).toBeVisible();
expect(screen.getByRole('combobox', { name: 'Add cast member' })).toBeVisible();
expect(screen.getByText('No character evolution authored yet.')).toBeVisible();
});
it('sends a plan with no lens as a body byte-identical to the pre-lens one', async () => {
api.updateLoom.mockResolvedValue(castLoom());
renderCastPlan({ loom: castLoom() });
fireEvent.click(screen.getByRole('tab', { name: 'Story arc' }));
fireEvent.change(screen.getByRole('textbox', { name: /story arc/i }), { target: { value: 'A stronger arc.' } });
fireEvent.click(screen.getByRole('button', { name: /save plan/i }));
await waitFor(() => expect(api.updateLoom).toHaveBeenCalled());
expect(Object.keys(savedPlan())).toEqual([
'storyArc', 'plotPoints', 'sideQuests', 'deliveryOptions', 'interEpisodeVoicemails', 'nextSeasonTeaser',
]);
});
it('authors a full five-stage lens against episode and scene evidence', async () => {
const user = userEvent.setup();
api.updateLoom.mockResolvedValue(castLoom());
renderCastPlan({ loom: castLoom() });
await user.selectOptions(screen.getByRole('combobox', { name: 'Add cast member' }), 'chr-1111');
await user.selectOptions(screen.getByRole('combobox', { name: 'Declared outcome' }), 'full-change');
for (const stage of ['control strategy failing', 'pressure forces exploration', 'commitment to change', 'cost tested', 'final proof']) {
fireEvent.change(screen.getByRole('textbox', { name: `${stage} — Belief under test` }), {
target: { value: `${stage}: usefulness buys safety` },
});
}
await user.selectOptions(screen.getByRole('combobox', { name: 'final proof — Evidence episode' }), 'ep-2');
await user.selectOptions(screen.getByRole('combobox', { name: 'final proof — Evidence scene' }), 'the-cost');
fireEvent.click(screen.getByRole('button', { name: /save plan/i }));
await waitFor(() => expect(api.updateLoom).toHaveBeenCalled());
const [lens] = savedPlan().characterEvolutions;
expect(lens).toMatchObject({ characterId: 'chr-1111', characterName: 'Vale' });
expect(lens.evolution.outcome).toBe('full-change');
expect(lens.evolution.stages.map((s) => s.stageId)).toEqual([
'control-strategy-failing', 'pressure-forces-exploration', 'commitment-to-change', 'cost-tested', 'final-proof',
]);
expect(lens.evolution.stages.at(-1).evidence).toMatchObject({ episodeId: 'ep-2', sceneKey: 'the-cost' });
});
it('keeps a sparse lens sparse and treats a declared flat arc as complete, not a defect', async () => {
const user = userEvent.setup();
api.updateLoom.mockResolvedValue(castLoom());
renderCastPlan({ loom: castLoom() });
await user.selectOptions(screen.getByRole('combobox', { name: 'Add cast member' }), 'chr-2222');
await user.selectOptions(screen.getByRole('combobox', { name: 'Declared outcome' }), 'flat-testing');
fireEvent.change(screen.getByRole('textbox', { name: 'control strategy failing — External pressure' }), {
target: { value: 'The town votes to abandon the relay.' },
});
fireEvent.change(screen.getByRole('textbox', { name: 'commitment to change — Character choice' }), {
target: { value: 'Stays, and changes the vote instead.' },
});
expect(screen.queryByRole('alert')).not.toBeInTheDocument();
expect(screen.getByRole('button', { name: /save plan/i })).toBeEnabled();
fireEvent.click(screen.getByRole('button', { name: /save plan/i }));
await waitFor(() => expect(api.updateLoom).toHaveBeenCalled());
const [lens] = savedPlan().characterEvolutions;
expect(lens.evolution.outcome).toBe('flat-testing');
expect(lens.evolution.stages.map((s) => s.stageId))
.toEqual(['control-strategy-failing', 'commitment-to-change']);
});
it('marks an unresolvable evidence anchor stale and re-picks it in one click', async () => {
const user = userEvent.setup();
api.updateLoom.mockResolvedValue(castLoom());
renderCastPlan({
loom: castLoom({
characterEvolutions: [{
characterId: 'chr-1111',
characterName: 'Vale',
evolution: {
outcome: 'partial-open',
outcomeNote: '',
stages: [{
stageId: 'cost-tested',
testedBelief: 'Usefulness buys safety.',
externalPressure: '',
characterChoice: '',
causalConsequence: '',
evidence: { atIssue: null, atSceneAnchor: '', transitionId: '', episodeId: 'ep-deleted', sceneKey: '' },
}],
},
}],
}),
});
await user.click(screen.getByText('Vale'));
expect(screen.getByText('Stale anchor')).toBeVisible();
expect(screen.getByRole('combobox', { name: 'cost tested — Evidence episode' }))
.toHaveValue('ep-deleted');
await user.click(screen.getByRole('button', { name: 'Re-pick cost tested anchor' }));
expect(screen.queryByText('Stale anchor')).not.toBeInTheDocument();
await user.selectOptions(screen.getByRole('combobox', { name: 'cost tested — Evidence episode' }), 'ep-1');
fireEvent.click(screen.getByRole('button', { name: /save plan/i }));
await waitFor(() => expect(api.updateLoom).toHaveBeenCalled());
expect(savedPlan().characterEvolutions[0].evolution.stages[0].evidence)
.toMatchObject({ episodeId: 'ep-1' });
});
it('persists a fully cleared lens as a clear rather than a no-op', async () => {
const user = userEvent.setup();
api.updateLoom.mockResolvedValue(castLoom());
renderCastPlan({
loom: castLoom({
characterEvolutions: [{
characterId: 'chr-1111',
characterName: 'Vale',
evolution: {
outcome: 'tragic-refusal',
outcomeNote: 'He never lets go.',
stages: [{
stageId: 'final-proof',
testedBelief: 'Usefulness buys safety.',
externalPressure: '',
characterChoice: '',
causalConsequence: '',
evidence: null,
}],
},
}],
}),
});
await user.click(screen.getByText('Vale'));
await user.selectOptions(screen.getByRole('combobox', { name: 'Declared outcome' }), '');
fireEvent.change(screen.getByRole('textbox', { name: 'Outcome note' }), { target: { value: '' } });
fireEvent.change(screen.getByRole('textbox', { name: 'final proof — Belief under test' }), { target: { value: '' } });
fireEvent.click(screen.getByRole('button', { name: /save plan/i }));
await waitFor(() => expect(api.updateLoom).toHaveBeenCalled());
expect(savedPlan().characterEvolutions[0].evolution).toBeNull();
});
it('shows the universe psychology profile as read-only baseline context', async () => {
const user = userEvent.setup();
renderCastPlan({
loom: castLoom({
characterEvolutions: [{ characterId: 'chr-1111', characterName: 'Vale', evolution: null }],
}),
});
await user.click(screen.getByText('Vale'));
await user.click(screen.getByText('Universe baseline (read-only)'));
expect(screen.getByText('Universe baseline (read-only)')).toBeVisible();
expect(screen.getByText('If I stay useful, nobody leaves.')).toBeVisible();
expect(screen.queryByRole('textbox', { name: /theory of control/i })).not.toBeInTheDocument();
});
});