@gentbajko/slopify 3.25.8 → 4.0.0

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 {};

package/dist/slices/assistant/asks.js

@@ -0,0 +1,80 @@
+import { z } from "zod";
+import { askWindowMs } from "./gate.js";
+import { askStates } from "./model.js";
+// What the assistant asked the person first, and their answer. An Allow is a grant for that
+// one call: used once, within 15 minutes, in the session it was asked in.
+const askRow = z.object({
+    id: z.string(),
+    session_id: z.string(),
+    tool: z.string(),
+    text: z.string(),
+    state: z.enum(askStates),
+    created_at: z.string(),
+    decided_at: z.string().nullable(),
+});
+function askOf(value) {
+    const row = askRow.parse(value);
+    return {
+        id: row.id,
+        sessionId: row.session_id,
+        tool: row.tool,
+        text: row.text,
+        state: row.state,
+        createdAt: row.created_at,
+        decidedAt: row.decided_at,
+    };
+}
+const columns = "id, session_id, tool, text, state, created_at, decided_at";
+function windowStart(now) {
+    return new Date(now.valueOf() - askWindowMs).toISOString();
+}
+// Asks nobody answered and Allows nobody used in time.
+function expire(db, now) {
+    const since = windowStart(now);
+    db.prepare("UPDATE assistant_asks SET state='expired' WHERE (state='asked' AND created_at<?) OR (state='allowed' AND decided_at<?)").run(since, since);
+}
+// The same call asked again while the first ask still waits is the same card.
+export function openAsk(db, ask, now) {
+    expire(db, now);
+    const waiting = db
+        .prepare(`SELECT ${columns} FROM assistant_asks WHERE session_id=? AND tool=? AND args_hash=? AND state='asked'`)
+        .get(ask.sessionId, ask.tool, ask.argsHash);
+    if (waiting !== undefined)
+        return askOf(waiting);
+    db.prepare("INSERT INTO assistant_asks(id, session_id, tool, args_hash, text, state, created_at) VALUES (?,?,?,?,?,'asked',?)").run(ask.id, ask.sessionId, ask.tool, ask.argsHash, ask.text, now.toISOString());
+    return askOf(db.prepare(`SELECT ${columns} FROM assistant_asks WHERE id=?`).get(ask.id));
+}
+export function decideAsk(db, id, answer, now) {
+    expire(db, now);
+    const found = db.prepare(`SELECT ${columns} FROM assistant_asks WHERE id=?`).get(id);
+    if (found === undefined)
+        return { ok: false, reason: "unknown" };
+    const ask = askOf(found);
+    if (ask.state === "expired")
+        return { ok: false, reason: "expired" };
+    if (ask.state !== "asked")
+        return { ok: false, reason: "decided" };
+    db.prepare("UPDATE assistant_asks SET state=?, decided_at=? WHERE id=? AND state='asked'").run(answer === "allow" ? "allowed" : "denied", now.toISOString(), id);
+    return {
+        ok: true,
+        ask: askOf(db.prepare(`SELECT ${columns} FROM assistant_asks WHERE id=?`).get(id)),
+    };
+}
+// Uses the person's Allow for this exact call, once. False when there is none to use.
+export function consumeGrant(db, grant, now) {
+    expire(db, now);
+    const used = db
+        .prepare(`UPDATE assistant_asks SET state='used' WHERE id=(
+         SELECT id FROM assistant_asks WHERE session_id=? AND tool=? AND args_hash=? AND state='allowed'
+         ORDER BY decided_at DESC LIMIT 1)
+       RETURNING id`)
+        .all(grant.sessionId, grant.tool, grant.argsHash);
+    return used.length > 0;
+}
+export function asksOf(db, sessionId, now) {
+    expire(db, now);
+    return db
+        .prepare(`SELECT ${columns} FROM assistant_asks WHERE session_id=? ORDER BY created_at, rowid`)
+        .all(sessionId)
+        .map(askOf);
+}

package/dist/slices/assistant/cost.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+// The cost sentence on an ask card, from the estimate the preview (Choose what to remake) or
+// Play's review already showed for this exact work.
+const money = (value) => `$${value.toFixed(2)}`;
+function range(low, high) {
+    return Math.abs(high - low) < 0.005 ? money(low) : `${money(low)}–${money(high)}`;
+}
+export function costSentence(estimates) {
+    const low = estimates.reduce((sum, one) => sum + one.low, 0);
+    const high = estimates.reduce((sum, one) => sum + one.high, 0);
+    const unknown = estimates.reduce((sum, one) => sum + one.unknown, 0);
+    const onPlan = estimates.some((one) => one.apiLow !== undefined);
+    const priced = high > 0 ? `estimated at ${range(low, high)}` : onPlan ? "" : "estimated at $0.00";
+    const plan = onPlan ? "part of it runs on your CLI plan's allowance" : "";
+    const unpriced = unknown === 0
+        ? ""
+        : `${String(unknown)} ${unknown === 1 ? "step has" : "steps have"} no price in the catalogue`;
+    const parts = [priced, plan, unpriced].filter((part) => part !== "");
+    return `This starts paid work${parts.length === 0 ? "" : `: ${parts.join("; ")}`}.`;
+}
+export const unpricedSentence = "This starts paid work; Slopify can't price it here.";
+// A schedule call starts nothing now: runs begin at the schedule's times, and are paid then.
+export function scheduleSentence(tool) {
+    switch (tool) {
+        case "create_schedule":
+            return "It starts active: runs start at the schedule's times and are paid then.";
+        case "update_schedule":
+            return "Runs start at the schedule's times and are paid then; a paused schedule stays paused, so nothing runs until you resume it.";
+        case "resume_schedule":
+            return "Runs start again at the schedule's times and are paid then.";
+        default:
+            return undefined;
+    }
+}
+const costsSchema = z
+    .object({
+    currency: z.literal("USD"),
+    low: z.number(),
+    high: z.number(),
+    unknown: z.number(),
+    apiLow: z.number().optional(),
+})
+    .loose();
+// The estimate a preview_rebuild or review_draft answer carries, keyed by the id the start
+// call names (previewId, reviewId).
+export function estimateOfAnswer(value) {
+    const preview = z.object({ id: z.string(), costs: costsSchema }).safeParse(value);
+    if (preview.success)
+        return { id: preview.data.id, estimates: [preview.data.costs] };
+    const review = z.object({ id: z.string(), estimates: z.array(costsSchema) }).safeParse(value);
+    if (review.success)
+        return { id: review.data.id, estimates: review.data.estimates };
+    return undefined;
+}

package/dist/slices/assistant/gate.js

@@ -0,0 +1,222 @@
+import { createHash } from "node:crypto";
+// "Ask first": which of Slopify's tools the assistant may only call once the person pressed
+// Allow, and how a later call is matched to that Allow. The model can't approve itself: a
+// call with confirmed: true counts only against a grant the person made (`repo.ts`).
+// Never offered to the assistant: an external review is the reviewing agent's or the
+// person's, the library's export and import move every prompt at once, uploads take files
+// from disk, and emptying the trash or deleting old versions can't be undone.
+export const assistantExcludedTools = new Set([
+    "submit_review_verdict",
+    "get_external_review",
+    "import_library",
+    "export_library",
+    "delete_from_trash",
+    "delete_from_trash_many",
+    "delete_old_versions",
+]);
+// The tools that start work a provider bills for (or that the plan's allowance pays for).
+export const assistantCostlyTools = [
+    "start_draft",
+    "start_rebuild",
+    "make_quick_short",
+    "make_full_video_draft",
+    "retry_stage",
+    "soften_stage",
+    "rerun_stage",
+    "resume_project",
+    "approve_checkpoint",
+    "generate_topics",
+    "generate_cast_picture",
+    "quote_voice_sample",
+    "prepare_topic",
+    "instantiate_template",
+    "approve_topic",
+    "approve_topics",
+    "approve_all_topics",
+    "switch_retired_model",
+    "switch_all_retired_models",
+    // Settings → Models' Check models sends each model one small paid request.
+    "check_models",
+    // Library → Designs: each draws a picture a provider bills for. A template's Save draws the
+    // editor's sample when it asks for one, so it asks whatever it sends.
+    "edit_design_picture",
+    "make_design_artwork",
+    "make_design_from_template",
+    "make_design_template_sample",
+    "retry_design_step",
+    "save_design_template",
+    // Library → Templates → Open studio: each makes (or remakes) a template's paid sample. A
+    // studio Save makes the paid sample of what changed when it asks for one, so it asks
+    // whatever it sends. The daily budget is the most the samples may spend, so raising it is
+    // the person's call too.
+    "save_template_studio",
+    "make_template_sample",
+    "set_sample_topic",
+    "set_sample_full_script",
+    "say_it_as",
+    "update_template_studio_settings",
+    // Redo makes a flagged item again with the provider.
+    "redo_review",
+    // Taking a checkpoint off lets the paid steps behind it start (one the run waits at must be
+    // approved instead, `edge/http/checkpoints.ts`).
+    "change_checkpoints",
+    // A schedule starts paid runs at its times: making, changing or resuming one decides them.
+    "create_schedule",
+    "update_schedule",
+    "resume_schedule",
+    // A restored project picks up where it was, paid steps included.
+    "restore_from_trash",
+    "restore_from_trash_many",
+];
+const costly = new Set(assistantCostlyTools);
+// The tools that send something out of Slopify, or choose where it is sent: words a page or a
+// file planted in the chat must not be able to point Slopify's notifications elsewhere.
+export const assistantOutwardTools = [
+    "set_notification_url",
+    "send_test_notification",
+    // Rescore sends each topic's title to search engines; Check providers asks every provider
+    // with the person's keys.
+    "score_topics",
+    "check_providers",
+];
+const outward = new Set(assistantOutwardTools);
+// Every other tool that changes something, named here so that a new one has to be put in one
+// list or the other (`edge/mcp/assistant.test.ts`): free to call, nothing billed or sent.
+export const assistantFreeTools = [
+    "move_projects_to_channel",
+    "move_in_run_queue",
+    "estimate_run",
+    "hide_autopilot_warning",
+    "set_weekly_report",
+    "mark_uploaded",
+    "keep_as_is",
+    "preview_added_output",
+    "add_output",
+    "overrule_review",
+    "edit_description_field",
+    "set_description_links",
+    "set_pack_slot",
+    "set_pack_real_footage",
+    "set_pack_pick",
+    "set_pack_playlists",
+    // A post's settings, text, Reddit fields and link: Fill in <site> stays the person's.
+    "set_post_choice",
+    "edit_post_text",
+    "set_reddit_post",
+    "set_post_link",
+    "remove_from_fill_queue",
+    "swap_releases",
+    "set_release",
+    "set_posting_plan",
+    "set_lead_time",
+    "set_youtube_link",
+    "pause_project",
+    "prepare_revision",
+    "save_revision",
+    "restore_revision",
+    "preview_rebuild",
+    "create_draft",
+    "save_draft",
+    "fork_draft",
+    "review_draft",
+    "create_template",
+    "template_from_project",
+    "next_chapter_template",
+    "update_template",
+    "pause_schedule",
+    "reject_topics",
+    "restore_topics",
+    "reject_topic",
+    "edit_held_topic",
+    "set_topic_queue",
+    "move_topic",
+    "transfer_topic",
+    "create_channel",
+    "update_channel",
+    "set_ai_disclosure",
+    "add_cast_member",
+    "move_cast_member",
+    "update_cast_member",
+    "set_channel_template",
+    "set_episode_memory",
+    "update_episode_memory",
+    "preview_channel_videos",
+    "import_channel_videos",
+    "create_design",
+    "update_design",
+    "quote_design_edit",
+    "quote_design_artwork",
+    "set_design_version",
+    "create_design_template",
+    "quote_design_template",
+    "create_prompt",
+    "update_prompt",
+    "set_prompt_photorealistic",
+    "restore_prompt_version",
+    "create_entry",
+    "update_entry",
+    "restore_entry_version",
+    "create_document_theme",
+    "update_document_theme",
+    "set_narration_aliases",
+    "update_settings",
+    "set_default_channel_links",
+    "add_voice",
+    "set_voice_languages",
+    "set_voice_real_person",
+    "set_studio_playlists",
+    "dismiss_model_notices",
+    // The published catalogue: read from Slopify's site, nothing of the person's goes with it.
+    "check_catalogue",
+    "refresh_catalogue",
+    "install_starter_pack",
+    "restore_samples",
+    "copy_sample",
+    "quote_template_save",
+    "quote_say_it_as",
+    "quote_samples_for_all",
+    "make_template_free_samples",
+    "quote_bakeoff",
+    // Prices remakes for several projects; starting each is start_rebuild's.
+    "preview_remake_outdated",
+];
+// Removing something (DELETE), anything the page confirms, paid work, and sending out.
+export function isGated(tool) {
+    return (tool.method === "DELETE" ||
+        tool.confirm !== undefined ||
+        costly.has(tool.name) ||
+        tool.sends === true ||
+        outward.has(tool.name));
+}
+export function isOutward(tool) {
+    return tool.sends === true || outward.has(tool.name);
+}
+// ceiling: an ask can be answered, and an Allow used, for 15 minutes. Past that the costs
+// may have moved, so the assistant has to ask again.
+export const askWindowMs = 15 * 60_000;
+// The same call is the same arguments, whatever key retries it and whether it says it is
+// confirmed: those two are what a call after Allow changes.
+export function argsHash(args) {
+    const { confirmed: _confirmed, body, ...rest } = args;
+    const kept = typeof body === "object" && body !== null && !Array.isArray(body)
+        ? { ...rest, body: withoutKey(body) }
+        : body === undefined
+            ? rest
+            : { ...rest, body };
+    return createHash("sha256").update(canonical(kept)).digest("hex");
+}
+function withoutKey(body) {
+    const { idempotencyKey: _key, ...rest } = body;
+    return rest;
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (typeof value === "object" && value !== null)
+        return `{${Object.entries(value)
+            .filter(([, one]) => one !== undefined)
+            .toSorted(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+            .map(([key, one]) => `${JSON.stringify(key)}:${canonical(one)}`)
+            .join(",")}}`;
+    return JSON.stringify(value) ?? "null";
+}