@gentbajko/slopify 3.25.9 → 4.1.0

package/dist/slices/admission/start.js

@@ -4,6 +4,8 @@ import { storeArticleText } from "../article/store.js";
 import { resolveChannelId, setProjectChannel } from "../channels/repo.js";
 import { defaultDocumentTheme } from "../document/model.js";
 import { earlierEpisodesFor } from "../episodes/related.js";
+import { keywordFactsFor } from "../keywords/facts.js";
+import { usesFacts } from "../keywords/rules.js";
 import { listNarrationAliases } from "../narration/aliases-library.js";
 import { currentPronunciationRules } from "../narration/pronunciation.js";
 import { collectSharedGlossary } from "../narration/shared-glossary.js";
@@ -33,37 +35,8 @@ export function initialState(source) {
 export function startRun(deps, draft, rendered, retainStaged = false, templates) {
     const id = deps.ids.next();
     const at = deps.clock.now().toISOString();
-    const shared = usesPronunciationGlossary(draft) && draft.audio?.shareGlossary === true
-        ? collectSharedGlossary(deps).entries
-        : [];
-    // Library → Aliases as they are now: later edits there never change this project.
-    const aliases = draft.sources.audio === "generate" && draft.audio?.useNarrationAliases === true
-        ? listNarrationAliases(deps.db)
-        : [];
-    // The title may name keywords too ("History: {{Topic}}"), filled like a prompt's, so a
-    // template or Play keeps the pattern and each project gets its own title.
-    const title = render(draft.title, draft.values).trim() || draft.title;
-    // The channel's related earlier episodes as they are now (`slices/episodes`): later edits
-    // there never change this project. A draft never brings its own.
-    const { earlierEpisodes: _carried, ...fresh } = draft;
-    const earlier = earlierEpisodesFor(deps.db, draft, title);
-    const config = {
-        ...fresh,
-        title,
-        ...(title !== draft.title && detectSlots(draft.title).names.length > 0
-            ? { titlePattern: draft.title }
-            : {}),
-        // A new project always names its document theme: a config without one reads as the
-        // DiceMaster of older projects (see documentThemeOf), which no new project should get.
-        ...(sourceOf(draft.sources, "document") === "generate" && draft.document === undefined
-            ? { document: { theme: defaultDocumentTheme } }
-            : {}),
-        rendered,
-        ...(shared.length === 0 ? {} : { sharedGlossary: shared }),
-        ...(aliases.length === 0 ? {} : { narrationAliases: aliases }),
-        pronunciationRules: currentPronunciationRules,
-        ...(earlier === undefined ? {} : { earlierEpisodes: earlier }),
-    };
+    const config = configOf(deps, draft, rendered, deps.clock.now(), templates);
+    const { title } = config;
     const project = {
         id,
         title,
@@ -130,6 +103,50 @@ export function startRun(deps, draft, rendered, retainStaged = false, templates)
     }
     return { project, stages };
 }
+// The config a run starts with: the draft as filled, with what Slopify copies in when it starts
+// (the shared glossary, Library → Aliases, the pronunciation rules, the channel's earlier
+// episodes) as they are now. The template studio saves its sample's next revision from it.
+export function configOf(deps, draft, rendered, now, templates, 
+// The project the config is for when it exists already (a template sample's next
+// revision): it is neither its own previous video nor one it covered before.
+projectId) {
+    const shared = usesPronunciationGlossary(draft) && draft.audio?.shareGlossary === true
+        ? collectSharedGlossary(deps).entries
+        : [];
+    // Library → Aliases as they are now: later edits there never change this project.
+    const aliases = draft.sources.audio === "generate" && draft.audio?.useNarrationAliases === true
+        ? listNarrationAliases(deps.db)
+        : [];
+    // The title may name keywords too ("History: {{Topic}}"), filled like a prompt's, so a
+    // template or Play keeps the pattern and each project gets its own title.
+    const title = render(draft.title, draft.values).trim() || draft.title;
+    // The channel's related earlier episodes as they are now (`slices/episodes`): later edits
+    // there never change this project. A draft never brings its own.
+    const { earlierEpisodes: _carried, keywordFacts: _facts, ...fresh } = draft;
+    const earlier = earlierEpisodesFor(deps.db, draft, title);
+    const titlePattern = title !== draft.title && detectSlots(draft.title).names.length > 0 ? draft.title : undefined;
+    // The facts the keywords Slopify fills come from, as they are now, and only when a picked
+    // prompt asks for one: a run that uses none saves the config it always did.
+    const facts = usesFacts(Object.values(templates ?? rendered))
+        ? keywordFactsFor(deps, { ...draft, title, titlePattern }, now, projectId)
+        : undefined;
+    return {
+        ...fresh,
+        title,
+        ...(titlePattern === undefined ? {} : { titlePattern }),
+        // A new project always names its document theme: a config without one reads as the
+        // DiceMaster of older projects (see documentThemeOf), which no new project should get.
+        ...(sourceOf(draft.sources, "document") === "generate" && draft.document === undefined
+            ? { document: { theme: defaultDocumentTheme } }
+            : {}),
+        rendered,
+        ...(shared.length === 0 ? {} : { sharedGlossary: shared }),
+        ...(aliases.length === 0 ? {} : { narrationAliases: aliases }),
+        pronunciationRules: currentPronunciationRules,
+        ...(earlier === undefined ? {} : { earlierEpisodes: earlier }),
+        ...(facts === undefined ? {} : { keywordFacts: facts }),
+    };
+}
 function attachProvided(deps, projectId, draft, collected, retainStaged) {
     const { sources, provided } = draft;
     if (sources.research === "provide" && provided.research !== undefined) {

package/dist/slices/admission/state-words.js

@@ -28,8 +28,13 @@ export const stageStateWords = {
 export const heldWord = "Waiting for your review";
 export const waitingForAgentWord = "Waiting for the agent";
 export const stoppedWord = "Stopped";
-export const preparedWord = "Prepared";
+// Made ahead by its schedule (Make ahead): everything but the video is made, and the video is
+// put together on the run's day.
+export const preparedWord = "Waiting for its day";
 export const keptAsIsWord = "Kept as is";
+// A running run whose only movement is a step that failed on something time can fix (a rate
+// limit, a dropped connection) and runs again by itself at a set time.
+export const retryingWord = "Waiting to try again";
 export const heldStateWords = [
     heldWord,
     waitingForAgentWord,
@@ -38,15 +43,25 @@ export const heldStateWords = [
     keptAsIsWord,
 ];
 // A run that ran and is held: a waiting project with some of its run done (`progress` is the
-// run's share done, `progressOf`) or a step failed, or one stopped or parked on an agent's review
-// before it got going. One with none done that waits for neither is Queued, waiting its turn.
+// run's share done, `progressOf`) or a step failed, one a checkpoint holds (it reached it with
+// every step before it supplied), or one stopped or parked on an agent's review before it got
+// going. One with none done that waits for none of these is Queued, waiting its turn.
 export function heldRun(project) {
     return (project.status === "pending" &&
         (project.progress > 0 ||
             project.stepFailed === true ||
+            (project.holding?.length ?? 0) > 0 ||
             project.stopped === true ||
             project.waitingForAgent === true));
 }
+// When the run tries again by itself: the soonest wait of a step that failed on something time
+// can fix, while no step runs. Undefined while one runs (the run reads Running) or none waits.
+export function retryingAt(stages) {
+    if (stages.some((stage) => stage.state === "running"))
+        return undefined;
+    const waits = stages.flatMap((stage) => stage.state === "pending" && typeof stage.retryAt === "string" ? [stage.retryAt] : []);
+    return waits.toSorted()[0];
+}
 // Whether the person is the one it waits for (to approve, or to Continue the run): not when it
 // is Kept as is, waits for an agent or for its scheduled day.
 function heldForPerson(project) {
@@ -78,9 +93,18 @@ export function runningNow(project) {
 export function queuedRun(project) {
     return project.status === "pending" && !heldRun(project);
 }
-// An uploaded project already reads "done" from the projects route (`uploadedAndSettled`).
+// A settled project already reads "done" from the projects route (`settledProjects`). A
+// running run that only waits to try a step again says so.
 export function projectStateWord(project) {
-    return heldRun(project) ? heldStateWord(project) : projectStateWords[project.status];
+    if (heldRun(project))
+        return heldStateWord(project);
+    if (retryingRun(project))
+        return retryingWord;
+    return projectStateWords[project.status];
+}
+// Running, and the one thing it does is wait to try a failed step again at a set time.
+export function retryingRun(project) {
+    return project.status === "running" && project.retryAt !== undefined;
 }
 // A run that ran and now waits for the person, held or paused: Home's Needs you, the Projects
 // "Needs you" filter and its waiting-first sort.
@@ -108,3 +132,8 @@ export function stepFailedWhileWaiting(status, stages) {
 export function failedRun(project) {
     return project.status === "failed" || project.stepFailed === true;
 }
+// Everything a run asks of the person, the one set Home's Needs you lists and the Projects
+// "Needs you" filter holds: a decision (approve, Continue the run, resume) or a failure to fix.
+export function needsYou(project) {
+    return waitsForPerson(project) || failedRun(project);
+}

package/dist/slices/admission/substitute.js

@@ -2,6 +2,7 @@
 // name case-sensitive and free to hold anything but `{`, `}` and a newline (so
 // `{{Middle of Words}}` is one name). There is no escape syntax. Hand-rolled on purpose: a
 // template library would bring its own grammar.
+import { keywordNames, legacyNames } from "../keywords/specs.js";
 export const slotLintKinds = ["unclosed", "empty", "nested"];
 export const fieldGroups = ["common", "text", "image"];
 // A well-formed slot: no brace and no newline between the delimiters.
@@ -38,16 +39,18 @@ export function detectSlots(body) {
     return { names, errors };
 }
 // Filled by Slopify, never by the person: each image's own scene, which the project's AI model
-// writes from the article when an image prompt asks for it (`images/scenes.ts`).
+// writes from the article when an image prompt asks for it (`images/scenes.ts`). The old name
+// of {{Slopify_Scene}}, which keeps its own meaning (`keywords/specs.ts`).
 export const sceneKeyword = "Scene";
 // Filled by Slopify too: how the video's subject and the characters in an image look, which the
 // project's AI model looks up on the web when a prompt asks for it (`images/appearance.ts`).
 export const appearanceKeyword = "Appearance";
-// The keywords Slopify fills itself, which are never fields for the person.
-export const filledKeywords = [sceneKeyword, appearanceKeyword];
+// The keywords Slopify fills itself, which are never fields for the person: every `Slopify_`
+// keyword and the two old names. An unknown `Slopify_` name is not one of them.
+export const filledKeywords = [...keywordNames, ...legacyNames];
 // One field per distinct name; Common when a name is used on both sides, otherwise Text or
 // Image. The order is first appearance, which is why both sides arrive as ordered lists of
-// bodies rather than as sets. The scene and appearance keywords are not fields: Slopify fills them.
+// bodies rather than as sets. The keywords Slopify fills are not fields.
 export function collectFields(textBodies, imageBodies) {
     const text = namesOf(textBodies);
     const image = namesOf(imageBodies);

package/dist/slices/agents/attention-posts.js

@@ -0,0 +1,31 @@
+import { projectById } from "../admission/repo.js";
+import { platformLabels } from "../social/model.js";
+import { postsIn } from "../social/repo.js";
+// Posts the extension filled in a site's form, waiting for the person to press Post (or
+// Schedule) there, and fills that stopped. Posting is the person's: an agent reports them.
+export function postsWaiting(deps) {
+    return postsIn(deps.db, ["filled", "failed"]).flatMap((post) => {
+        const project = projectById(deps.db, post.projectId);
+        if (project === undefined)
+            return [];
+        const site = platformLabels[post.platform];
+        const filled = post.state === "filled";
+        return [
+            {
+                kind: filled ? "post-due" : "extension-failure",
+                since: (filled ? post.filledAt : post.updatedAt) ?? post.updatedAt ?? "",
+                projectId: post.projectId,
+                title: project.title,
+                stage: "video",
+                itemKey: `social:${post.platform}`,
+                reason: filled
+                    ? `The ${site} post is filled in ${site}'s form and waits for the person to press Post there. Posting is the person's: report it.`
+                    : `Filling the ${site} post failed: ${post.message ?? "the extension gave no reason."} Fixing it is the extension's or the person's: report it.`,
+                autoRetryInFlight: false,
+                agentCanAct: false,
+                ids: { projectId: post.projectId, platform: post.platform },
+                tools: ["get_post_packs"],
+            },
+        ];
+    });
+}

package/dist/slices/agents/attention-templates.js

@@ -0,0 +1,33 @@
+import { z } from "zod";
+import { notReadySentence } from "../template-studio/schedule-gate.js";
+import { rowsOf } from "./attention-work.js";
+const scheduleRow = z.object({ id: z.string(), name: z.string(), template_id: z.string() });
+// An active schedule whose gated template has no version it may run skips every run until the
+// person marks one ready: the agent reports it. The gate keeps no time it began, so it is dated
+// when it is read.
+export function templatesNotReady(db, now, skip, notReady = (id) => notReadySentence(db, id)) {
+    const rows = db
+        .prepare("SELECT id, name, template_id FROM schedules WHERE deleted_at IS NULL AND status='active' AND template_kind='project' ORDER BY lower(name), id")
+        .all();
+    return rowsOf(rows, "schedules", skip, (value) => {
+        const row = scheduleRow.parse(value);
+        const sentence = notReady(row.template_id);
+        return sentence === undefined
+            ? []
+            : [
+                {
+                    kind: "template-not-ready",
+                    since: now.toISOString(),
+                    projectId: null,
+                    title: row.name,
+                    stage: null,
+                    itemKey: null,
+                    reason: `${sentence} Marking a version ready is the person's: report it.`,
+                    autoRetryInFlight: false,
+                    agentCanAct: false,
+                    ids: { id: row.id, templateId: row.template_id },
+                    tools: ["get_schedule", "get_template_checks"],
+                },
+            ];
+    });
+}

package/dist/slices/agents/attention.js

@@ -4,7 +4,10 @@ import { liveProject } from "../admission/repo.js";
 import { externalReviewOf } from "../reviews/external-rows.js";
 import { waitingExternalReviewRows } from "../reviews/external-waiting.js";
 import { projectHolds } from "../reviews/holds.js";
+import { templateSampleProjects } from "../template-studio/repo.js";
 import { setAsideProjects } from "../uploads/repo.js";
+import { postsWaiting } from "./attention-posts.js";
+import { templatesNotReady } from "./attention-templates.js";
 import { extensionFailures, failedSteps, heldTopics, lateUploads, pausedRuns, rowsOf, stoppedRuns, } from "./attention-work.js";
 export const attentionKinds = [
     "external-review",
@@ -16,6 +19,9 @@ export const attentionKinds = [
     "held-topics",
     "late-upload",
     "extension-failure",
+    "template-not-ready",
+    // A post filled in another site's form, waiting for the person to press Post (`slices/social`).
+    "post-due",
 ];
 const projectOf = z.object({ project_id: z.string() });
 // Oldest first. A project Kept as is waits for nobody, so none of its entries is listed. Each
@@ -47,8 +53,11 @@ export function needsAttention(deps, now) {
         ["held topics", () => heldTopics(db, skip)],
         ["late uploads", () => lateUploads(deps, now)],
         ["extension failures", () => extensionFailures(db, skip)],
+        ["templates not ready", () => templatesNotReady(db, now, skip, deps.notReady)],
+        ["posts", () => postsWaiting(deps)],
     ];
     const aside = setAsideProjects(db);
+    const samples = templateSampleProjects(db);
     return sources
         .flatMap(([source, entries]) => {
         try {
@@ -61,7 +70,7 @@ export function needsAttention(deps, now) {
             return [];
         }
     })
-        .filter((entry) => entry.projectId === null || !aside.has(entry.projectId))
+        .filter((entry) => entry.projectId === null || (!aside.has(entry.projectId) && !samples.has(entry.projectId)))
         .toSorted((a, b) => a.since.localeCompare(b.since));
 }
 function titles(db) {

package/dist/slices/agents/connection.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { readSetting, writeSetting } from "../settings/repo.js";
+import { readJsonSetting, writeSetting } from "../settings/repo.js";
 // When an agent last opened an MCP session. This install's own fact, so backups leave it out
 // (`storage/portable.ts`).
 export const agentConnectionKey = "agents.lastConnectedAt";
@@ -7,9 +7,5 @@ export function recordAgentConnection(db, at) {
     writeSetting(db, agentConnectionKey, JSON.stringify(at));
 }
 export function lastAgentConnection(db) {
-    const raw = readSetting(db, agentConnectionKey);
-    if (raw === undefined)
-        return null;
-    const parsed = z.iso.datetime().safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : null;
+    return readJsonSetting(db, agentConnectionKey, z.iso.datetime(), null);
 }

package/dist/slices/agents/model.js

@@ -1,7 +1,10 @@
 import { z } from "zod";
-// Agents: an AI agent (Claude Code, Codex, ...) driving Slopify through its MCP endpoint.
-// Browser-safe: Settings → Connections → Agents (MCP) builds its setup lines from these.
-export const actors = ["person", "agent"];
+// Agents: an AI agent (Claude Code, Codex, ...) driving Slopify through its MCP endpoint, and
+// the in-app assistant, which drives it the same way from Slopify's own chat. Browser-safe:
+// Settings → Connections → Agents (MCP) builds its setup lines from these.
+export const actors = ["person", "agent", "assistant"];
+// Who an MCP call recorded in `agent_actions` came from.
+export const agentActors = ["agent", "assistant"];
 export const mcpPath = "/mcp";
 export function mcpUrl(origin) {
     return `${origin.replace(/\/+$/, "")}${mcpPath}`;

package/dist/slices/agents/repo.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { actors } from "./model.js";
+import { actors, agentActors } from "./model.js";
 // ceiling: Settings shows the latest twenty; a project's own are in its history.
 export const recentAgentActionsMax = 20;
 const actionRow = z.object({
@@ -10,6 +10,7 @@ const actionRow = z.object({
     title: z.string(),
     revision_id: z.string().nullable(),
     created_at: z.string(),
+    actor: z.enum(agentActors),
 });
 function actionOf(value) {
     const row = actionRow.parse(value);
@@ -21,16 +22,17 @@ function actionOf(value) {
         title: row.title,
         revisionId: row.revision_id,
         createdAt: row.created_at,
+        actor: row.actor,
     };
 }
 // A project the call itself deleted for good is gone: the action is kept without it. A call
 // sent again with its idempotencyKey was answered with its first answer, so it adds no second
 // row (`agent_actions_once`); any other failure to record it is thrown.
 export function recordAgentAction(db, action, idempotencyKey) {
-    db.prepare(`INSERT INTO agent_actions(id,project_id,schedule_id,tool,title,revision_id,created_at,idempotency_key)
-     VALUES (?,(SELECT id FROM projects WHERE id=?),?,?,?,?,?,?)
+    db.prepare(`INSERT INTO agent_actions(id,project_id,schedule_id,tool,title,revision_id,created_at,idempotency_key,actor)
+     VALUES (?,(SELECT id FROM projects WHERE id=?),?,?,?,?,?,?,?)
      ON CONFLICT(tool,COALESCE(project_id,''),idempotency_key) WHERE idempotency_key IS NOT NULL
-     DO NOTHING`).run(action.id, action.projectId, action.scheduleId, action.tool, action.title, action.revisionId, action.createdAt, idempotencyKey ?? null);
+     DO NOTHING`).run(action.id, action.projectId, action.scheduleId, action.tool, action.title, action.revisionId, action.createdAt, idempotencyKey ?? null, action.actor);
 }
 export function agentActionsOf(db, projectId) {
     return db
@@ -38,12 +40,18 @@ export function agentActionsOf(db, projectId) {
         .all(projectId)
         .map(actionOf);
 }
-export function agentRevisionIds(db, projectId) {
+function revisionIdsBy(db, projectId, actor) {
     return new Set(db
-        .prepare("SELECT DISTINCT revision_id FROM agent_actions WHERE project_id=? AND revision_id IS NOT NULL")
-        .all(projectId)
+        .prepare("SELECT DISTINCT revision_id FROM agent_actions WHERE project_id=? AND actor=? AND revision_id IS NOT NULL")
+        .all(projectId, actor)
         .map((row) => String(row.revision_id)));
 }
+export function agentRevisionIds(db, projectId) {
+    return revisionIdsBy(db, projectId, "agent");
+}
+export function assistantRevisionIds(db, projectId) {
+    return revisionIdsBy(db, projectId, "assistant");
+}
 export function recentAgentActions(db) {
     return db
         .prepare(`SELECT a.*, COALESCE(p.title, s.name) AS subject FROM agent_actions a

package/dist/slices/article/continuation.js

@@ -1,9 +1,5 @@
-import { noTokens, plusUsage } from "../telemetry/model.js";
 // At most 3 continuations; still unfinished after the third is a failed attempt.
 export const continuationLimit = 3;
-// The provider's own word for "I stopped because I ran out of room", which is what every
-// adapter maps its finish reason to (`kernel/ports/llm.ts`).
-const truncatedReason = "length";
 // A fixed 'Research notes' header followed by the notes, then the rendered article prompt;
 // without research, the rendered prompt alone. One user message, and no parameters of the app's
 // own: the provider's defaults are used.
@@ -35,62 +31,3 @@ export function continuationMessages(base, soFar) {
         },
     ];
 }
-export async function writeArticle(providers, choice, brief, onDelta) {
-    const base = articleMessages(brief);
-    const sent = [{ label: "Article", messages: base }];
-    const stream = (event) => {
-        if (event.type === "delta") {
-            onDelta(event.text);
-        }
-    };
-    let result = await providers.llm({
-        provider: choice.provider,
-        model: choice.model,
-        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
-        messages: base,
-        check: written,
-    }, stream);
-    if (!result.ok)
-        return result;
-    let answer = result.value;
-    const pieces = [answer.text];
-    let tokens = plusUsage(noTokens, answer.usage);
-    for (let n = 1; truncated(answer) && n <= continuationLimit; n += 1) {
-        const messages = continuationMessages(base, pieces.join(""));
-        sent.push({ label: `Continuation ${String(n)}`, messages });
-        result = await providers.llm({
-            provider: choice.provider,
-            model: choice.model,
-            ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
-            messages,
-            // The last continuation allowed is the one that has to end the article: a fourth
-            // truncation is a failed attempt, which is the wrapper's to retry. The
-            // loop therefore never sees a truncated answer with its budget spent.
-            check: n === continuationLimit ? finished : written,
-        }, stream);
-        if (!result.ok)
-            return result;
-        answer = result.value;
-        pieces.push(answer.text);
-        tokens = plusUsage(tokens, answer.usage);
-    }
-    return { ok: true, value: { markdown: pieces.join(""), sent, tokens } };
-}
-function truncated(answer) {
-    return answer.finishReason === truncatedReason;
-}
-// Empty response → failed attempt.
-function written(answer) {
-    return answer.text.trim() === ""
-        ? "The AI model returned an empty article. Try again; if it keeps happening, choose a different model in Edit project → Providers."
-        : undefined;
-}
-function finished(answer) {
-    const empty = written(answer);
-    if (empty !== undefined) {
-        return empty;
-    }
-    return truncated(answer)
-        ? `The article was still unfinished after ${String(continuationLimit)} continuations because the AI model kept stopping at its length limit. Ask for a shorter article in Edit project → Prompts, or choose a model with a larger output limit in Edit project → Providers, then Try again.`
-        : undefined;
-}

package/dist/slices/article/plain.js

@@ -1,6 +1,7 @@
 import { remark } from "remark";
 import remarkGfm from "remark-gfm";
 import stripMarkdown from "strip-markdown";
+import { internalError } from "../../kernel/errors.js";
 // ceiling: conversions remembered. The same article is converted again every time a run plans
 // its work, which is several times a step; a long article took seconds each time, on the
 // thread that answers the page. The oldest goes first.
@@ -26,11 +27,11 @@ function convert(markdown) {
     const paragraphs = tree.children
         .map((node) => {
         if (node.type !== "paragraph")
-            throw new Error("Slopify hit an internal error (the article couldn't be turned into plain text). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+            throw new Error(internalError("the article couldn't be turned into plain text"));
         return node.children
             .map((child) => {
             if (child.type !== "text")
-                throw new Error("Slopify hit an internal error (the article couldn't be turned into plain text). Try again; if it happens again, use Download diagnostics in Settings and report it.");
+                throw new Error(internalError("the article couldn't be turned into plain text"));
             return child.value;
         })
             .join("");

package/dist/slices/article/segments.js

@@ -1,41 +1,6 @@
-import { insertPiece, piecesOf, setPiece } from "../../kernel/runner/piece-repo.js";
 import { subjectOf } from "../admission/model.js";
-import { noTokens, plusUsage } from "../telemetry/model.js";
-export const categories = ["intro", "outro"];
-export async function writeSegment(providers, choice, config, category, article, sent) {
-    const picked = config[category];
-    if (picked === undefined)
-        return { ok: true, value: undefined };
-    const body = config.rendered[category];
-    if (body === undefined)
-        throw new Error(`Slopify hit an internal error (the ${category} text was never filled in). Try again; if it happens again, use Download diagnostics in Settings and report it.`);
-    const common = { category, name: picked.name, mode: picked.mode };
-    if (picked.mode === "text")
-        return { ok: true, value: { ...common, text: body, tokens: noTokens } };
-    if (choice === undefined)
-        throw new Error(`No AI model is set for writing the ${category}. Choose one in Edit project → Providers, then Try again.`);
-    const messages = segmentMessages(body, config, article);
-    sent.push({ label: category === "intro" ? "Intro" : "Outro", messages });
-    const answer = await providers.llm({
-        provider: choice.provider,
-        model: choice.model,
-        ...(choice.thinking === undefined ? {} : { thinking: choice.thinking }),
-        messages,
-        check: (given) => given.text.trim() === ""
-            ? `The AI model returned an empty ${category}. Try again; if it keeps happening, choose a different model in Edit project → Providers.`
-            : undefined,
-    });
-    if (!answer.ok)
-        return answer;
-    return {
-        ok: true,
-        value: {
-            ...common,
-            text: answer.value.text.trim(),
-            tokens: plusUsage(noTokens, answer.value.usage),
-        },
-    };
-}
+// The message an intro or outro is written from by the text model: its prompt, the title, the
+// run's keywords and the article's plain text (`rebuild/recipe-text.ts`).
 export function segmentMessages(body, config, article) {
     const values = Object.entries(config.values);
     return [
@@ -59,28 +24,3 @@ export function segmentMessages(body, config, article) {
         },
     ];
 }
-export function keepSegment(deps, context, segment, idx) {
-    const payload = JSON.stringify({
-        category: segment.category,
-        name: segment.name,
-        mode: segment.mode,
-        text: segment.text,
-    });
-    const existing = piecesOf(deps.db, context.stage.id, "segment").find((piece) => piece.idx === idx);
-    if (existing === undefined) {
-        insertPiece(deps.db, {
-            id: deps.ids.next(),
-            stageId: context.stage.id,
-            kind: "segment",
-            idx,
-            state: "done",
-            payload,
-        });
-    }
-    else
-        setPiece(deps.db, existing.id, "done", payload);
-}
-export function instructionsText(sent) {
-    const parts = sent.map((one) => `=== ${one.label} ===\n\n${one.messages.map((message) => message.content).join("\n\n")}`);
-    return `${parts.join("\n\n")}\n`;
-}

package/dist/slices/assistant/access.js

@@ -0,0 +1 @@
+export {};