@gentbajko/slopify 3.25.8 → 4.0.0

package/dist/main.js

@@ -7,9 +7,12 @@ import ffmpegStatic from "ffmpeg-static";
 import { buildRegistry } from "./adapter-registry.js";
 import { alignSubtitlesWith } from "./adapters/alignment/index.js";
 import { prefetchModel } from "./adapters/alignment/prefetch.js";
-import { prepareFfmpeg } from "./adapters/ffmpeg.js";
+import { ffmpegOutput, prepareFfmpeg } from "./adapters/ffmpeg.js";
 import { createHostCliClient } from "./adapters/host-cli/index.js";
+import { createSearchInterest } from "./adapters/interest/search-interest.js";
 import { nodeRunCli } from "./adapters/llm/run-cli.js";
+import { assistantSelfUrl, wireAssistant } from "./assistant-wiring.js";
+import { startAutopilot } from "./autopilot-timers.js";
 import { curateRegistry } from "./catalog/registry.js";
 import { createCatalogueStore } from "./catalog/store.js";
 import { createAutostart } from "./edge/autostart/index.js";
@@ -20,6 +23,8 @@ import { createApp } from "./edge/http/app.js";
 import { createMutationLifecycle, drainMutationsWithDeadline } from "./edge/http/mutations.js";
 import { limitRequestTimes } from "./edge/http/timeouts.js";
 import { openFolder } from "./edge/open-folder.js";
+import { nodeTailscaleRun } from "./edge/remote-access/cli.js";
+import { createRemoteAccessService } from "./edge/remote-access/service.js";
 import { readHostLogin } from "./host-cli/status.js";
 import { createAudioPreviewStore } from "./kernel/audio-preview.js";
 import { systemClock } from "./kernel/clock.js";
@@ -30,7 +35,7 @@ import { causedBy } from "./kernel/errors.js";
 import { ulidIds } from "./kernel/ids.js";
 import { acquireInstanceLock } from "./kernel/lock.js";
 import { openLog } from "./kernel/log.js";
-import { attachPlaces, ensureDataDirs, ensureDirs, layout, repoint, subtitleModelDir, } from "./kernel/paths.js";
+import { attachPlaces, attachSamples, ensureDataDirs, ensureDirs, layout, repoint, subtitleModelDir, } from "./kernel/paths.js";
 import { stageKinds } from "./kernel/pipeline.js";
 import { sqliteAttempts } from "./kernel/runner/attempt-repo.js";
 import { auditionVoice } from "./kernel/runner/audition.js";
@@ -41,14 +46,24 @@ import { createProviderQueue } from "./kernel/runner/queue.js";
 import { standaloneImage, standaloneLlm } from "./kernel/runner/standalone.js";
 import { readVersion } from "./kernel/version.js";
 import { modelSources } from "./model-catalog.js";
+import { cliWatcher, lookAtModels, wireModelChecks } from "./model-checks.js";
 import { projectPaused, projectTrashed } from "./slices/admission/repo.js";
 import { createBackupService } from "./slices/backups/service.js";
 import { pumpQueue, queueWaiting } from "./slices/batch/index.js";
 import { settleInterruptedCastImages } from "./slices/channels/cast-images.js";
 import { approveCheckpoint } from "./slices/checkpoints/index.js";
 import { checkpointDecisionForWork, recoverCheckpointWork, settleReleasedCheckpoints, } from "./slices/checkpoints/recovery.js";
+import { dailySampleBudget } from "./slices/designs/budget.js";
+import { designCheckContext } from "./slices/designs/check-context.js";
+import { contextChecks, sampleCheck } from "./slices/designs/gate.js";
+import { runPdfWorker } from "./slices/designs/pdf-runner.js";
+import { createDesignRenderer } from "./slices/designs/render.js";
+import { createDesignRunner } from "./slices/designs/runner.js";
+import { createDesignSamples } from "./slices/designs/sample.js";
 import { createEpisodeMemoryWatcher, } from "./slices/episodes/summarize.js";
 import { resolveFont } from "./slices/fonts/index.js";
+import { accessRecorder } from "./slices/model-checks/record.js";
+import { readChecks } from "./slices/model-checks/repo.js";
 import { decodePeaks } from "./slices/narration/peaks.js";
 import { projectLink } from "./slices/notifications/address.js";
 import { createNotificationSender } from "./slices/notifications/send.js";
@@ -68,13 +83,15 @@ import { releaseDueReviews } from "./slices/reviews/external-release.js";
 import { currentRevisionId } from "./slices/revisions/repo.js";
 import { createLimitGate, resumeAfterRestart } from "./slices/run-cost/limits.js";
 import { createStandaloneMeter, createUsageMeter } from "./slices/run-cost/meter.js";
+import { refreshDesignSchedules } from "./slices/schedules/next-run.js";
 import { settleTerminalScheduleRuns } from "./slices/schedules/repo.js";
 import { createScheduleRunner } from "./slices/schedules/scheduler.js";
 import { nodeCliProbe } from "./slices/settings/cli-status.js";
-import { isLocalCliProvider, localCliConcurrency } from "./slices/settings/model.js";
+import { isLocalCliProvider, localCliConcurrency, providerIds } from "./slices/settings/model.js";
 import { readSettings } from "./slices/settings/playback.js";
 import { providerStatuses } from "./slices/settings/readiness.js";
 import { readSetting } from "./slices/settings/repo.js";
+import { createReshaper } from "./slices/social/reshape.js";
 import { arrangeChanged } from "./slices/storage/arrange.js";
 import { busyProjects } from "./slices/storage/backup-export.js";
 import { documentsDir, nodeDocumentsHost } from "./slices/storage/documents.js";
@@ -83,13 +100,27 @@ import { createPlaces, recoverPlaces } from "./slices/storage/places.js";
 import { reconcileStorage } from "./slices/storage/reconcile.js";
 import { installUnpackedExtension, unpackedExtensionDir, } from "./slices/studio/unpacked.js";
 import { previewPictures } from "./slices/style-preview/images.js";
+import { bundledSampleAssets } from "./slices/style-preview/narration.js";
 import { ffmpegStylePreview } from "./slices/style-preview/render.js";
 import { createStylePreviews, stylePreviewDir } from "./slices/style-preview/service.js";
 import { collectorEndpoint, httpPostEvents } from "./slices/telemetry/collector-client.js";
 import { createFlusher } from "./slices/telemetry/flush.js";
-import { record } from "./slices/telemetry/record.js";
+import { record, skippingProjects } from "./slices/telemetry/record.js";
+import { makeBakeoff } from "./slices/template-studio/bakeoff-make.js";
+import { readStudioSettings } from "./slices/template-studio/budget.js";
+import { createDocumentSamples } from "./slices/template-studio/document-sample.js";
+import { createFreeSamples } from "./slices/template-studio/free.js";
+import { createLoudnessSamples } from "./slices/template-studio/loudness.js";
+import { sampleMaker } from "./slices/template-studio/make.js";
+import { makePaidSample } from "./slices/template-studio/paid.js";
+import { sampleProjects, templateSampleCheck } from "./slices/template-studio/repo.js";
+import { createSampleRunner } from "./slices/template-studio/runner.js";
+import { storedUnknownAcks } from "./slices/template-studio/save.js";
+import { notReadySentence, runnableTemplate, templateGate, } from "./slices/template-studio/schedule-gate.js";
+import { createPriceCache } from "./slices/template-studio/service.js";
 import { createTrashPurge } from "./slices/trash/service.js";
-import { probeDurationMs } from "./slices/video/ffmpeg.js";
+import { createNvencProbe, noNvenc, renderMachine, } from "./slices/video/encoding.js";
+import { probeDurationMs, runFfmpegAt } from "./slices/video/ffmpeg.js";
 import { watchActivation } from "./updater/candidate.js";
 import { launchUpdate } from "./updater/install.js";
 import { isUpdateToken } from "./updater/model.js";
@@ -103,6 +134,21 @@ import { workInProgress } from "./updater/work-in-progress.js";
 const flushDelayMs = 1000;
 const collectorTimeoutMs = 10_000;
 const mutationDrainTimeoutMs = 5_000;
+// ceiling: removing the serve handler is two quick tailscale calls; a hung Tailscale must not
+// hold the shutdown, and the next start removes or replaces what is left.
+const remoteAccessStopMs = 5_000;
+// ceiling: an image call usually answers within a minute; shutdown waits no longer than this
+// for one already sent, and the next start marks a step still making as stopped.
+const designIdleMs = 60_000;
+function withDeadline(work, ms) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, ms);
+        void work.finally(() => {
+            clearTimeout(timer);
+            resolve();
+        });
+    });
+}
 export function createScheduleTickLifecycle(deps) {
     let stopping = false;
     let inflight;
@@ -195,6 +241,9 @@ export async function boot(config, options = {}) {
         recoverPlaces(db, paths);
         const places = createPlaces(db);
         attachPlaces(paths, places);
+        // A template's studio sample keeps its folder in the data dir, never in Projects
+        // (`slices/template-studio`): set before anything reads or reconciles a project's files.
+        attachSamples(paths, sampleProjects(db, paths.dataDir));
         const runtimeDb = db;
         const interrupted = markInterruptedStages(db, clock);
         recoverCheckpointWork(db);
@@ -205,6 +254,17 @@ export async function boot(config, options = {}) {
         // candidate's committed activation pointer has been verified.
         const reconciled = pendingActivation ? undefined : reconcileStorage(db, paths);
         const log = openLog(paths.logs, clock);
+        // Settings → Production defaults → Video encoder: the bundled ffmpeg first, then the
+        // computer's own. Asked once, when the settings page or a render first needs it.
+        const nvenc = createNvencProbe({
+            candidates: [ffmpeg, "ffmpeg", "/usr/bin/ffmpeg"],
+            exec: ffmpegOutput,
+            log,
+        });
+        // Settings → Production defaults → Render priority for the ffmpeg work outside a project's
+        // render (Template Studio's samples, designs' drawing, posts' pictures), read as each starts.
+        const renderPriority = () => readSettings({ db: runtimeDb, log }).renderPriority;
+        const runFfmpeg = runFfmpegAt(renderPriority);
         log.write("info", "boot", {
             detail: reconciled === undefined
                 ? `interrupted stages ${interrupted}, settled schedules ${settledSchedules}, storage reconciliation deferred during update activation`
@@ -225,6 +285,8 @@ export async function boot(config, options = {}) {
             ids,
             log,
             presentEvent: eventPresenter(eventDb),
+            // A template's hidden sample is told to its studio, never to the shell or Home.
+            quiet: templateSampleCheck(eventDb),
         }), (event) => {
             notifier.observe(event);
             episodes?.observe(event);
@@ -252,11 +314,15 @@ export async function boot(config, options = {}) {
         }), catalogue);
         // Calls that belong to no project (topic generation, episode summaries, cast pictures)
         // still go through the attempt wrapper, and are metered against their schedule or channel.
+        // What real calls teach about each model for the person's keys and logins (Settings →
+        // Models, the pickers); no run reads it back.
+        const access = accessRecorder({ db, clock });
         const standalone = {
             registry,
             clock,
             log,
             meter: createStandaloneMeter({ db, ids, clock, catalogue: () => catalogue.read() }),
+            access,
         };
         episodes = createEpisodeMemoryWatcher({
             db,
@@ -285,6 +351,7 @@ export async function boot(config, options = {}) {
             registry,
             catalogue,
             ffmpeg,
+            nvenc,
             audioPreviews,
         });
         const updateDb = db;
@@ -306,6 +373,8 @@ export async function boot(config, options = {}) {
         // Folders are renamed only by a version that is committed: an update on trial can still be
         // rolled back to a version that knows only id-named folders.
         let arrangeAllowed = !pendingActivation;
+        // What an update waits for that only lives in memory; set once those parts are wired.
+        let liveWork = () => undefined;
         const updater = createUpdater({
             ...(isUpdateToken(candidateToken)
                 ? {
@@ -348,9 +417,8 @@ export async function boot(config, options = {}) {
                         ? "npm was not found, so in-app updates are off. Install Node.js with npm (https://nodejs.org), or update from the terminal: npx @gentbajko/slopify@latest"
                         : undefined,
             // An update never installs while a job is going (`updater/work-in-progress.ts`).
-            busy: () => workInProgress(updateDb, (id) => runner.hasInflight?.(id) === true, Date.now()) !==
-                undefined,
-            busyWith: () => workInProgress(updateDb, (id) => runner.hasInflight?.(id) === true, Date.now()),
+            busy: () => workInProgress(updateDb, (id) => runner.hasInflight?.(id) === true, Date.now(), liveWork) !== undefined,
+            busyWith: () => workInProgress(updateDb, (id) => runner.hasInflight?.(id) === true, Date.now(), liveWork),
             report: (message) => log.write("warn", "update", { detail: message }),
             install: async (next, restarting) => {
                 if (npm === undefined)
@@ -384,6 +452,18 @@ export async function boot(config, options = {}) {
             modelsFor: modelSources(registry).modelsFor,
             emit: (projectId, event) => hub.emit(projectId, event),
         };
+        // Which models work for the person's keys and logins (Settings → Models, the pickers).
+        const { checks: modelChecks, listing: modelListing } = wireModelChecks({
+            db,
+            clock,
+            log,
+            registry,
+            catalogue: () => catalogue.read(),
+            lifecycle: catalogue.lifecycle,
+            fetch: globalThis.fetch,
+            statuses: rebuild.providers,
+        });
+        const autoModelChecks = options.refreshModels === true;
         // Redos a review asked for before the last shutdown start now.
         reviewRedos.bind(rebuild);
         reviewRedos.kick();
@@ -421,10 +501,20 @@ export async function boot(config, options = {}) {
                 flusher.soon();
             },
         };
+        // Built with the designs further down; design schedules make their pieces with it.
+        let designMake;
         const scheduleRunnerDeps = {
             ...draftDeps,
-            template: (id) => templateById(runtimeDb, id),
+            designs: () => designMake,
+            // The newest version that may run: legacy, marked ready, or carried by Slopify. Only a
+            // project template's: a design schedule asks the designs (runnableDesignVersion).
+            template: (id) => runnableTemplate(runtimeDb, id),
+            notReady: (id) => notReadySentence(runtimeDb, id),
+            templateHead: (id) => templateById(runtimeDb, id),
+            templateGate: (id) => templateGate(runtimeDb, id),
             topicLlm: (call) => standaloneLlm(standalone, call),
+            // Asked only for schedules set to rank topics by public search interest.
+            interest: createSearchInterest({ fetch: globalThis.fetch, version, now: () => clock.now() }),
             topicsWaiting: (event) => {
                 hub.emitGlobal(event);
                 notifier.observeTopics(event);
@@ -443,6 +533,59 @@ export async function boot(config, options = {}) {
                 detail: "Scheduled jobs could not be advanced.",
             }),
         });
+        // Library → Templates → Open studio: its free samples, made one job at a time in the
+        // background (`slices/template-studio/runner.ts`).
+        const stylePreviews = createStylePreviews({
+            dir: stylePreviewDir(paths.dataDir),
+            render: ffmpegStylePreview({
+                ffmpeg,
+                paths,
+                log,
+                dir: stylePreviewDir(paths.dataDir),
+                // Encoded and prioritised as this computer's videos are (`slices/video/encoding.ts`).
+                machine: async () => (await renderMachine({ settings: readSettings({ db: runtimeDb, log }), nvenc, log }))
+                    .machine,
+            }),
+            pictures: previewPictures({ db, paths }),
+            log,
+        });
+        const studioCache = join(paths.dataDir, "cache", "template-studio");
+        const loudnessSamples = createLoudnessSamples({
+            ffmpeg,
+            dir: join(studioCache, "loudness"),
+            source: bundledSampleAssets().narration,
+            log,
+            priority: renderPriority,
+        });
+        const documentSamples = createDocumentSamples({ dir: join(studioCache, "document") });
+        const freeSamples = createFreeSamples({
+            stylePreviews,
+            loudness: loudnessSamples,
+            documents: documentSamples,
+            loudnessDefault: () => readSettings({ db: runtimeDb, log }).loudness,
+        });
+        const studioPrices = createPriceCache();
+        // The unknown prices accepted on Save, shared by the studio's routes and its sample loop,
+        // and kept across restarts.
+        const studioAcks = storedUnknownAcks(db);
+        const sampleChanged = (templateId) => hub.emitGlobal({ type: "template.sample", templateId });
+        const sampleRunner = createSampleRunner({
+            db,
+            log,
+            changed: sampleChanged,
+            make: sampleMaker({
+                db,
+                free: freeSamples,
+                prices: studioPrices,
+                review: draftDeps,
+                changed: sampleChanged,
+                // Paid samples run on their hidden project through the same engine as every project.
+                paid: (job, signal) => makePaidSample({ start: draftDeps, rebuild, acks: studioAcks }, job, signal),
+                // Compare models: copies of the sample, made one bake-off at a time on the same loop.
+                bakeoff: (job, signal) => makeBakeoff({ start: draftDeps, rebuild }, job, signal),
+            }),
+        });
+        sampleRunner.start();
         const mutations = createMutationLifecycle();
         const folderConfiguration = await dockerFolderConfiguration(process.env, paths.projects);
         const filesService = createFilesService({
@@ -489,6 +632,18 @@ export async function boot(config, options = {}) {
             version,
             env: process.env,
         });
+        // Settings → General → Remote access. It proxies to the port the server really got, read
+        // when it applies; nothing applies before the server listens.
+        const remoteAccess = createRemoteAccessService({
+            db,
+            run: nodeTailscaleRun(process.platform),
+            platform: process.platform,
+            container: process.env.SLOPIFY_CONTAINER === "1",
+            listenHost: config.host,
+            port: () => listeningPort,
+            log,
+            now: () => Date.now(),
+        });
         if (options.refreshAutostart === true)
             void autostart.refresh().catch((error) => {
                 log.write("warn", "autostart.refresh", { detail: causedBy(error) });
@@ -505,8 +660,109 @@ export async function boot(config, options = {}) {
             catch (error) {
                 log.write("warn", "studio.extension", { detail: causedBy(error) });
             }
+        const autopilot = startAutopilot({
+            db: updateDb,
+            clock,
+            log,
+            dataDir: paths.dataDir,
+            template: (id) => templateById(updateDb, id),
+            catalogue: () => catalogue.read(),
+            fetch: globalThis.fetch,
+            send: sendNotification,
+            hostCli,
+            readLogin: readHostLogin,
+        });
+        // The assistant panel's chat: turns on this computer's Claude Code or Codex, reaching this
+        // server's own `/mcp/assistant`. In the Docker copy it says why it isn't there.
+        const assistant = wireAssistant({
+            db: updateDb,
+            ids,
+            clock,
+            log,
+            emit: hub.emitGlobal,
+            spawn: nodeRunCli,
+            probe: nodeCliProbe,
+            readLogin: readHostLogin,
+            selfUrl: () => assistantSelfUrl(config.host, listeningPort),
+            container: hostCli !== undefined,
+        });
+        // Library → Designs: paid pictures through the attempt wrapper, metered on the design;
+        // drawing in a child ffmpeg and PDFs in a forked worker, never on this thread.
+        // The template editor's samples hear when a sample's picture lands, to start the next.
+        let designSamples;
+        const designService = {
+            db,
+            clock,
+            ids,
+            paths,
+            log,
+            emit: (event) => {
+                hub.emitGlobal(event);
+                if (event.type === "design.changed")
+                    designSamples?.designChanged(event.designId);
+            },
+        };
+        const designRenderer = createDesignRenderer({
+            db,
+            paths,
+            log,
+            clock,
+            ffmpeg,
+            runFfmpeg,
+            font: (fontId) => resolveFont(paths, fontId),
+            pdf: (job, signal) => runPdfWorker(job, signal),
+        });
+        const designRunner = createDesignRunner({
+            ...designService,
+            catalogue: () => catalogue.read(),
+            generate: ({ designId, ...call }) => standaloneImage(standalone, { ...call, owner: { kind: "design", id: designId } }),
+            shrink: (bytes) => designRenderer.shrink(bytes, AbortSignal.timeout(120_000)),
+        });
+        designRunner.recover();
+        liveWork = () => modelChecks.running().length > 0
+            ? "the model checks"
+            : assistant.turnsRunning() > 0
+                ? "the assistant's answer"
+                : undefined;
+        designMake = {
+            service: designService,
+            runner: designRunner,
+            catalogue: () => catalogue.read(),
+        };
+        designSamples = createDesignSamples({
+            service: designService,
+            runner: designRunner,
+            catalogue: () => catalogue.read(),
+            budget: () => dailySampleBudget(runtimeDb, log),
+            plans: () => readStudioSettings(runtimeDb).samplesUsePlans,
+            timeZone: () => Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC",
+        });
+        designSamples.recover();
+        const designChecks = designCheckContext({
+            resolveFont: (fontId) => resolveFont(paths, fontId),
+            providers: rebuild.providers,
+        });
         const app = createApp({
+            assistant,
+            autopilot,
+            designs: { service: designService, runner: designRunner, renderer: designRenderer },
+            // Pictures cut to a post's shape, in a child ffmpeg like the designs' drawing.
+            social: { reshaper: createReshaper({ paths, ffmpeg, runFfmpeg, log }) },
+            designTemplates: {
+                service: designService,
+                runner: designRunner,
+                catalogue: () => catalogue.read(),
+                checks: async (templateId, doc, version) => [
+                    ...(await contextChecks(doc, templateId, designChecks)),
+                    sampleCheck(runtimeDb, templateId, version),
+                ],
+                samples: designSamples,
+                templateChanged: (templateId) => {
+                    refreshDesignSchedules(runtimeDb, templateId, clock.now());
+                },
+            },
             autostart,
+            remoteAccess,
             rebuild,
             drafts: draftDeps,
             schedules: scheduleDeps,
@@ -523,20 +779,29 @@ export async function boot(config, options = {}) {
             db,
             paths,
             host: config.host,
+            allowedHosts: (process.env.SLOPIFY_ALLOWED_HOSTS ?? "")
+                .split(",")
+                .map((name) => name.trim())
+                .filter((name) => name !== ""),
             hub,
             runner,
             updater,
             mutations,
             sendNotification,
+            nvenc,
             audioPreviews,
-            stylePreviews: createStylePreviews({
-                dir: stylePreviewDir(paths.dataDir),
-                render: ffmpegStylePreview({ ffmpeg, paths, log, dir: stylePreviewDir(paths.dataDir) }),
-                pictures: previewPictures({ db, paths }),
-                log,
-            }),
+            stylePreviews,
+            templateStudio: {
+                free: freeSamples,
+                prices: studioPrices,
+                wake: sampleRunner.wake,
+                acks: studioAcks,
+                loudnessSource: loudnessSamples.source,
+                loudnessFile: loudnessSamples.file,
+                documentFile: documentSamples.file,
+            },
             ...modelSources(registry),
-            audition: (call, signal) => auditionVoice({ registry, clock, log }, call, signal),
+            audition: (call, signal) => auditionVoice({ registry, clock, log, access }, call, signal),
             voiceLanguages: async (provider, voiceId, signal) => {
                 try {
                     return await registry.tts(provider).voiceLanguages?.(voiceId, signal);
@@ -546,6 +811,9 @@ export async function boot(config, options = {}) {
                 }
             },
             catalogue,
+            modelChecks,
+            modelListing,
+            autoModelChecks,
             clock,
             ids,
             log,
@@ -627,12 +895,28 @@ export async function boot(config, options = {}) {
             catalogue.sync().then((status) => {
                 if (status.warning !== null)
                     log.write("warn", "model-catalog.sync", { detail: status.warning });
+                // A model new to the list may already be on the person's key's own list.
+                for (const provider of new Set(status.changes.added.map((added) => added.provider)))
+                    if (isProviderId(provider))
+                        void modelListing.refresh(provider, true).catch((error) => {
+                            log.write("warn", "model-checks.listing", { detail: causedBy(error) });
+                        });
             }, (error) => log.write("warn", "model-catalog.sync", { detail: causedBy(error) }));
         };
         syncModels();
+        // Model checks look hourly too: the weekly look, and a CLI that became usable. Both run in
+        // the background and never hold a request or a run.
+        const lookForClis = cliWatcher(modelChecks, rebuild.providers, (provider) => readChecks(updateDb, provider).length > 0);
+        const lookForModels = () => {
+            if (!autoModelChecks)
+                return;
+            lookAtModels(modelChecks, lookForClis).catch((error) => log.write("warn", "model-checks", { detail: causedBy(error) }));
+        };
+        lookForModels();
         const modelTimer = setInterval(() => {
             if (catalogue.syncDue?.(Date.now()) === true)
                 syncModels();
+            lookForModels();
         }, 60 * 60_000);
         const backupTimer = setInterval(() => {
             backups.tick().catch((error) => {
@@ -685,6 +969,11 @@ export async function boot(config, options = {}) {
         };
         const arrangeTimer = setInterval(arrange, 5_000);
         listeningPort = portOf(server) ?? config.port;
+        // Never awaited: Tailscale's answer must not hold the start-up. A problem is logged with
+        // its fix and shown in Settings.
+        void remoteAccess.start().catch((error) => {
+            log.write("warn", "remote-access.start", { detail: causedBy(error) });
+        });
         // Whatever last run left queued goes out at start. Nothing waits for
         // it, and an unreachable collector costs one refused socket.
         flusher.soon();
@@ -715,13 +1004,22 @@ export async function boot(config, options = {}) {
                 clearInterval(trashTimer);
                 clearInterval(arrangeTimer);
                 clearInterval(modelTimer);
+                modelChecks.stop();
+                autopilot.stop();
                 const mutationDrain = mutations.stop();
                 const scheduleDrain = scheduleTicks.stop();
                 const topicDrain = scheduleRunner.stop();
+                // A local sample render is stopped and its job queued again at the next start.
+                const sampleDrain = sampleRunner.stop();
                 // A backup being written is stopped and its partial file removed, not waited for.
                 const backupDrain = backups.stop();
                 const serverClose = beginServerClose(server);
                 stopActivation();
+                // Slopify's serve handler goes with it, so no proxy points at a port another program
+                // could take while Slopify is stopped; the next start puts it back.
+                const remoteDrain = withDeadline(remoteAccess.stop().catch((error) => {
+                    log.write("warn", "remote-access.stop", { detail: causedBy(error) });
+                }), remoteAccessStopMs);
                 audioPreviews.close();
                 modelPrefetch.abort();
                 try {
@@ -730,7 +1028,13 @@ export async function boot(config, options = {}) {
                     await drainMutationsWithDeadline(mutationDrain, serverClose.terminate, mutationDrainTimeoutMs);
                     await scheduleDrain;
                     await topicDrain;
+                    await sampleDrain;
                     await backupDrain;
+                    await remoteDrain;
+                    // An assistant turn left running would keep spending the person's plan.
+                    await assistant.stopAll();
+                    // A picture call already sent is paid for: let it land rather than lose it.
+                    await withDeadline(designRunner.idle(), designIdleMs);
                     await runner.abortAll();
                     await episodes?.settled();
                 }
@@ -764,16 +1068,16 @@ export async function boot(config, options = {}) {
         throw error;
     }
 }
-export function wireRunner({ onFinished, audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, 
+export function wireRunner({ onFinished, audioPreviews, db, paths, clock, ids, log, hub, telemetry, flusher, registry, catalogue, ffmpeg, nvenc = async () => ({ available: false, reason: noNvenc }), 
 // Settings → Production defaults → Subtitle timing model, read as each alignment starts.
 alignSubtitles: aligner = alignSubtitlesWith(() => readSettings({ db, log }).subtitleModel), }) {
     // A stage counts what it did and the queue is flushed after each new event. `record`
     // swallows its own failures, so this can neither fail a stage nor widen what leaves the
     // machine - the payload allow-list is checked inside it.
-    const count = (type, counters) => {
+    const count = skippingProjects((type, counters) => {
         record(telemetry, type, counters);
         flusher.soon();
-    };
+    }, templateSampleCheck(db));
     const execution = {
         db,
         paths,
@@ -782,6 +1086,8 @@ alignSubtitles: aligner = alignSubtitlesWith(() => readSettings({ db, log }).sub
         log,
         ffmpeg,
         alignSubtitles: aligner,
+        // Settings → Production defaults → Rendering, read as each render starts.
+        renderMachine: (projectId) => renderMachine({ settings: readSettings({ db, log }), nvenc, log, projectId }),
         audioPreviews,
         count,
     };
@@ -793,6 +1099,7 @@ alignSubtitles: aligner = alignSubtitlesWith(() => readSettings({ db, log }).sub
         clock,
         log,
         meter: createUsageMeter({ db, ids, clock, catalogue: () => catalogue.read() }),
+        access: accessRecorder({ db, clock }),
         limits: createLimitGate({
             db,
             clock,
@@ -873,6 +1180,11 @@ alignSubtitles: aligner = alignSubtitlesWith(() => readSettings({ db, log }).sub
         emitRunningCount: (running) => {
             hub.emitGlobal({ type: "running.count", count: running });
         },
+        // The shell's "N running" leaves out the template studio's hidden samples.
+        counted: (() => {
+            const sample = templateSampleCheck(db);
+            return (projectId) => !sample(projectId);
+        })(),
         log,
     });
     return { ...runner, checkpoints };
@@ -921,6 +1233,9 @@ export function urlOf(host, port) {
 }
 // A stage can only be `running` at boot if the previous process died mid-run;
 // nothing auto-resumes, the user retries by hand.
+function isProviderId(id) {
+    return providerIds.includes(id);
+}
 export function markInterruptedStages(db, clock) {
     const result = db
         .prepare("UPDATE stages SET state = CASE WHEN EXISTS (SELECT 1 FROM project_controls WHERE project_id = stages.project_id AND paused = 1) THEN 'pending' ELSE 'failed' END, failure_reason = CASE WHEN EXISTS (SELECT 1 FROM project_controls WHERE project_id = stages.project_id AND paused = 1) THEN NULL ELSE 'interrupted' END, finished_at = CASE WHEN EXISTS (SELECT 1 FROM project_controls WHERE project_id = stages.project_id AND paused = 1) THEN NULL ELSE ? END WHERE state = 'running'")