@avocadostudio-ai/orchestrator-core 0.22.0 → 0.23.0

package/dist/agent/agent-loop-openai.js

@@ -44,7 +44,9 @@ export async function* runOpenAIAgentLoop(options) {
             log.info(`[agent-loop-openai] Calling OpenAI API (streaming), turn ${toolCallCount + 1}`);
             const stream = await client.chat.completions.create({
                 model,
-                max_tokens: AGENT_MAX_TOKENS,
+                // `max_tokens` is rejected by the gpt-5 family (the default agent model);
+                // `max_completion_tokens` is accepted by every current chat model.
+                max_completion_tokens: AGENT_MAX_TOKENS,
                 messages,
                 tools: openAITools,
                 stream: true,

package/dist/agent/agent-provider.js

@@ -20,8 +20,8 @@ export function detectProviderFromKey(key) {
 // Agent mode defaults (env-configurable)
 // ---------------------------------------------------------------------------
 const DEFAULT_MODELS = {
-    anthropic: process.env.AGENT_ANTHROPIC_MODEL ?? "claude-sonnet-5",
-    openai: process.env.AGENT_OPENAI_MODEL ?? "gpt-4o",
+    anthropic: process.env.AGENT_ANTHROPIC_MODEL ?? "claude-sonnet-5-5",
+    openai: process.env.AGENT_OPENAI_MODEL ?? "gpt-5.6-terra",
 };
 /** Max tool calls before the agent loop stops. */
 export const AGENT_MAX_TOOL_CALLS = Number(process.env.AGENT_MAX_TOOL_CALLS) || 20;

package/dist/agents/backtest.d.ts

@@ -0,0 +1,35 @@
+import { type VersionEntry } from "../state/session-state.ts";
+export type BacktestExample = {
+    slug: string;
+    text: string;
+    at?: string;
+};
+export type AgentBacktest = {
+    agentId: string;
+    /** Findings today, or — for Edit safety — past edits that would have been flagged. */
+    count: number;
+    examples: BacktestExample[];
+    /** Edit safety only: how many AI edits it looked at. */
+    checked?: number;
+};
+export type SiteBacktest = {
+    agents: AgentBacktest[];
+    pages: number;
+    /** The oldest entry the replay could read, ISO. Absent when there is no history. */
+    historySince?: string;
+    historyEntries: number;
+};
+/**
+ * Replay the version log for Edit safety.
+ *
+ * Only chat and MCP versions are edits it would have checked. Each is diffed
+ * against the version of the same page before it. The log does not keep the
+ * ops, only their names, so a version whose batch contained a `remove_block`
+ * does not report dropped blocks — the replay cannot tell which one was meant.
+ */
+export declare function replayEditSafety(entries: VersionEntry[]): {
+    flagged: number;
+    checked: number;
+    examples: BacktestExample[];
+};
+export declare function backtestSite(scopeKey: string): Promise<SiteBacktest>;

package/dist/agents/backtest.js

@@ -0,0 +1,92 @@
+import { buildBlockManifest } from "@avocadostudio-ai/shared";
+import { evaluateDraftChecks } from "../checks/run-checks.js";
+import { getSessionDraft, getSiteConfig, versionLog } from "../state/session-state.js";
+import { getSiteAssets } from "../state/site-assets.js";
+import { agentForRule, BUILTIN_AGENT_IDS } from "./builtins.js";
+import { evaluateAgentSpec } from "./run-spec.js";
+import { resolveSiteAgents } from "./settings.js";
+import { describeIssues, detectEditDamage } from "./edit-safety.js";
+const EXAMPLES = 3;
+/**
+ * Replay the version log for Edit safety.
+ *
+ * Only chat and MCP versions are edits it would have checked. Each is diffed
+ * against the version of the same page before it. The log does not keep the
+ * ops, only their names, so a version whose batch contained a `remove_block`
+ * does not report dropped blocks — the replay cannot tell which one was meant.
+ */
+export function replayEditSafety(entries) {
+    const manifest = buildBlockManifest();
+    const lastBySlug = new Map();
+    const examples = [];
+    let flagged = 0;
+    let checked = 0;
+    for (const entry of entries) {
+        const previous = lastBySlug.get(entry.slug);
+        if (entry.snapshot !== undefined)
+            lastBySlug.set(entry.slug, entry);
+        const byMachine = entry.source === "chat" || entry.actor?.kind === "mcp";
+        if (!byMachine || !previous?.snapshot || !entry.snapshot)
+            continue;
+        checked += 1;
+        let issues = detectEditDamage({ slug: entry.slug, before: previous.snapshot, after: entry.snapshot, ops: [], manifest });
+        if (entry.opTypes.includes("remove_block"))
+            issues = issues.filter((issue) => issue.kind !== "block_dropped");
+        if (issues.length === 0)
+            continue;
+        flagged += 1;
+        if (examples.length < EXAMPLES) {
+            examples.push({ slug: entry.slug, text: `“${entry.summary.slice(0, 80)}” also ${describeIssues(issues)}`, at: entry.at });
+        }
+    }
+    return { flagged, checked, examples };
+}
+export async function backtestSite(scopeKey) {
+    const pages = [...getSessionDraft(scopeKey).values()];
+    const assets = await getSiteAssets();
+    const { findings } = evaluateDraftChecks({
+        scopeKey,
+        pages,
+        manifest: buildBlockManifest(),
+        siteConfig: getSiteConfig(scopeKey),
+        ...(assets ? { assets } : {})
+    });
+    findings.sort((a, b) => (b.impact ?? 0) - (a.impact ?? 0));
+    const entries = versionLog.get(scopeKey) ?? [];
+    const replay = replayEditSafety(entries);
+    const agents = BUILTIN_AGENT_IDS.map((agentId) => {
+        if (agentId === "edit-safety") {
+            return { agentId, count: replay.flagged, examples: replay.examples, checked: replay.checked };
+        }
+        const mine = findings.filter((f) => agentForRule(f.ruleId) === agentId);
+        return {
+            agentId,
+            count: mine.length,
+            examples: mine.slice(0, EXAMPLES).map((f) => ({ slug: f.slug, text: f.title }))
+        };
+    });
+    // Custom agents are tried the same way: their spec, over today's pages.
+    const site = await resolveSiteAgents(scopeKey);
+    for (const agent of site.agents) {
+        if (agent.builtin)
+            continue;
+        try {
+            const found = await evaluateAgentSpec(scopeKey, agent.spec);
+            found.sort((a, b) => (b.impact ?? 0) - (a.impact ?? 0));
+            agents.push({
+                agentId: agent.agentId,
+                count: found.length,
+                examples: found.slice(0, EXAMPLES).map((f) => ({ slug: f.slug, text: f.title }))
+            });
+        }
+        catch {
+            agents.push({ agentId: agent.agentId, count: 0, examples: [] });
+        }
+    }
+    return {
+        agents,
+        pages: pages.length,
+        ...(entries[0]?.at ? { historySince: entries[0].at } : {}),
+        historyEntries: entries.length
+    };
+}

package/dist/agents/builtins.d.ts

@@ -0,0 +1,21 @@
+import type { AgentSpec } from "./spec.ts";
+export declare const BUILTIN_AGENT_IDS: readonly ["edit-safety", "unfinished-work", "search-health", "translation-drift"];
+export type BuiltinAgentId = (typeof BUILTIN_AGENT_IDS)[number];
+export declare function isBuiltinAgentId(value: unknown): value is BuiltinAgentId;
+/**
+ * Whether an agent is on for a site nobody has set up yet.
+ *
+ * "Degrade to exactly today" (site-ops-agents.md §7): the draft checker ran
+ * before any of this existed, so its two agents stay on. Edit safety is new
+ * and holds publish when it fires, so it waits until someone switches it on
+ * and names who hears from it.
+ */
+export declare const DEFAULT_ENABLED: Record<BuiltinAgentId, boolean>;
+export declare function agentForRule(ruleId: string): BuiltinAgentId;
+/**
+ * The three built-ins in the same shape a custom agent has. Search health and
+ * Unfinished work are the draft checker's rules, split by job; Edit safety is
+ * its before/after diff. Turning one on and writing a custom agent are the
+ * same action with a different starting spec.
+ */
+export declare const BUILTIN_SPECS: Record<BuiltinAgentId, AgentSpec>;

package/dist/agents/builtins.js

@@ -0,0 +1,102 @@
+import { DRAFT_RULES } from "../checks/rules-draft.js";
+import { I18N_RULES } from "../checks/rules-i18n.js";
+/*
+ * The built-in agents of phase 1 (docs/ideas/site-ops-agents.md §8 items 0–3).
+ *
+ * Three, not the four the plan launches with: Freshness is deferred. Each is a
+ * fixed-rule agent — none calls a model — and two of them are the draft
+ * checker that already ships, split by the job an ops person would name
+ * rather than by the `agent` string the rules happen to carry.
+ *
+ * Copy (names, the one-line job) lives in the editor's locale files, not
+ * here: the server hands out ids and state, the reader's language is the
+ * editor's business.
+ */
+export const BUILTIN_AGENT_IDS = ["edit-safety", "unfinished-work", "search-health", "translation-drift"];
+export function isBuiltinAgentId(value) {
+    return typeof value === "string" && BUILTIN_AGENT_IDS.includes(value);
+}
+/**
+ * Whether an agent is on for a site nobody has set up yet.
+ *
+ * "Degrade to exactly today" (site-ops-agents.md §7): the draft checker ran
+ * before any of this existed, so its two agents stay on. Edit safety is new
+ * and holds publish when it fires, so it waits until someone switches it on
+ * and names who hears from it.
+ */
+export const DEFAULT_ENABLED = {
+    "edit-safety": false,
+    "unfinished-work": true,
+    "search-health": true,
+    // Off until someone switches it on: it means nothing on a site with one language.
+    "translation-drift": false
+};
+/** The rule ids Unfinished work owns. Every other draft rule is Search health. */
+const UNFINISHED_WORK_RULES = new Set(["content.unfinished"]);
+/** Which built-in agent answers for a finding from the draft checker. */
+const TRANSLATION_RULES = new Set(I18N_RULES.map((rule) => rule.id));
+export function agentForRule(ruleId) {
+    if (UNFINISHED_WORK_RULES.has(ruleId))
+        return "unfinished-work";
+    if (TRANSLATION_RULES.has(ruleId))
+        return "translation-drift";
+    return "search-health";
+}
+// ---------------------------------------------------------------------------
+// The built-ins as specs (site-ops-agents.md SO-04)
+// ---------------------------------------------------------------------------
+/**
+ * The three built-ins in the same shape a custom agent has. Search health and
+ * Unfinished work are the draft checker's rules, split by job; Edit safety is
+ * its before/after diff. Turning one on and writing a custom agent are the
+ * same action with a different starting spec.
+ */
+export const BUILTIN_SPECS = {
+    "edit-safety": {
+        id: "edit-safety",
+        name: "Edit safety",
+        brief: "Check every AI and MCP edit for damage nobody asked for, and offer a one-click revert.",
+        origin: "builtin",
+        trigger: { kind: "event", on: "apply" },
+        scope: {},
+        detect: [{ template: "edit-damage", params: {} }],
+        severity: "error"
+    },
+    "unfinished-work": {
+        id: "unfinished-work",
+        name: "Unfinished work",
+        brief: "Placeholder text the editor inserted that nobody replaced.",
+        origin: "builtin",
+        trigger: { kind: "event", on: "publish" },
+        scope: {},
+        detect: [{ template: "draft-rule", params: { ruleIds: [...UNFINISHED_WORK_RULES] } }],
+        severity: "warning"
+    },
+    "search-health": {
+        id: "search-health",
+        name: "Search health",
+        brief: "Titles, descriptions, headings, alt text and dead links, ranked by how much each page matters.",
+        origin: "builtin",
+        trigger: { kind: "event", on: "publish" },
+        scope: {},
+        detect: [
+            {
+                template: "draft-rule",
+                params: {
+                    ruleIds: DRAFT_RULES.map((rule) => rule.id).filter((id) => !UNFINISHED_WORK_RULES.has(id) && !TRANSLATION_RULES.has(id))
+                }
+            }
+        ],
+        severity: "warning"
+    },
+    "translation-drift": {
+        id: "translation-drift",
+        name: "Translation drift",
+        brief: "Translated pages that no longer match their source page: missing blocks, text left untranslated, and source edits since.",
+        origin: "builtin",
+        trigger: { kind: "event", on: "publish" },
+        scope: {},
+        detect: [{ template: "draft-rule", params: { ruleIds: [...TRANSLATION_RULES] } }],
+        severity: "warning"
+    }
+};

package/dist/agents/draft-spec.d.ts

@@ -0,0 +1,44 @@
+import { type PageDoc } from "@avocadostudio-ai/shared";
+import type { Logger } from "../logger.ts";
+import { type AgentSpec } from "./spec.ts";
+export type DraftClient = {
+    messages: {
+        create(params: Record<string, unknown>, options?: {
+            signal?: AbortSignal;
+        }): Promise<{
+            content: Array<{
+                type: string;
+                text?: string;
+            }>;
+            stop_reason?: string | null;
+        }>;
+    };
+};
+export type DraftResult = {
+    ok: true;
+    spec: AgentSpec;
+} | {
+    ok: false;
+    reason: "cannot";
+    message: string;
+} | {
+    ok: false;
+    reason: "invalid";
+    message: string;
+};
+/** What the model needs to name real fields: each block type on the site and its field names. */
+export declare function siteSummary(pages: PageDoc[]): {
+    pages: string[];
+    blocks: Record<string, string[]>;
+};
+/** `custom:` + the name, lowercased and dashed, made unique among the site's agents. */
+export declare function customIdFor(name: string, taken: Set<string>): string;
+export declare function draftAgentSpec(args: {
+    scopeKey: string;
+    sentence: string;
+    /** The editor's locale; English when absent or unknown. */
+    locale?: string;
+    client?: DraftClient;
+    model?: string;
+    log?: Logger;
+}): Promise<DraftResult>;

package/dist/agents/draft-spec.js

@@ -0,0 +1,195 @@
+import { buildBlockManifest } from "@avocadostudio-ai/shared";
+import { walkPageFields, fieldText } from "../checks/field-walk.js";
+import { getAnthropicClient } from "../chat/anthropic-planner.js";
+import { defaultModelLookup } from "../chat/model-defaults.js";
+import { getSessionDraft } from "../state/session-state.js";
+import { resolveSiteAgents } from "./settings.js";
+import { parseCustomSpec } from "./spec.js";
+import { compileSpec, RULE_TEMPLATES } from "./templates.js";
+const MAX_SENTENCE = 500;
+const TIMEOUT_MS = 60_000;
+/** Field names shown per block type. Enough to name the right one; bounded so a big site stays cheap. */
+const MAX_FIELDS_PER_TYPE = 40;
+/*
+ * Every property is required and an absent one is null — the shape
+ * structured outputs accept, written the way plan-json-schema.ts writes it.
+ */
+const nullable = (schema) => ({ anyOf: [schema, { type: "null" }] });
+const str = { type: "string" };
+const strList = { type: "array", items: str };
+const DRAFT_JSON_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    required: ["cannot", "name", "brief", "trigger", "scope", "detect", "severity"],
+    properties: {
+        cannot: { ...nullable(str), description: "Set only when no template can check what was asked; say what is missing." },
+        name: { type: "string" },
+        brief: { type: "string" },
+        trigger: {
+            type: "object",
+            additionalProperties: false,
+            required: ["kind", "on", "every", "hour", "weekday"],
+            properties: {
+                kind: { type: "string", enum: ["manual", "event", "schedule"] },
+                on: nullable({ type: "string", enum: ["apply", "publish"] }),
+                every: nullable({ type: "string", enum: ["day", "week"] }),
+                hour: nullable({ type: "integer" }),
+                weekday: nullable({ type: "integer" })
+            }
+        },
+        scope: {
+            type: "object",
+            additionalProperties: false,
+            required: ["slugs", "exclude", "blockTypes"],
+            properties: {
+                slugs: nullable(strList),
+                exclude: nullable(strList),
+                blockTypes: nullable(strList)
+            }
+        },
+        detect: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: ["template", "params"],
+                properties: {
+                    template: { type: "string" },
+                    params: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["field", "blockType", "pattern", "caseSensitive", "fields", "title", "days"],
+                        properties: {
+                            field: nullable(str),
+                            blockType: nullable(str),
+                            pattern: nullable(str),
+                            caseSensitive: nullable({ type: "boolean" }),
+                            fields: nullable(strList),
+                            title: nullable(str),
+                            days: nullable({ type: "integer" })
+                        }
+                    }
+                }
+            }
+        },
+        severity: { type: "string", enum: ["error", "warning", "info"] }
+    }
+};
+function systemPrompt() {
+    const templates = RULE_TEMPLATES.filter((template) => template.runnable && template.id !== "draft-rule")
+        .map((template) => `- ${template.id}: ${template.description} Example params: ${JSON.stringify(template.example)}`)
+        .join("\n");
+    return [
+        "You turn one sentence from a website operator into a monitoring agent for their site.",
+        "An agent is a list of detect steps, each one of these rule templates:",
+        templates,
+        "",
+        "Rules:",
+        "- Use only field names and block types from the site summary you are given. A template matches a field by its own name (the last part of its path), so `date` matches `items[2].date`.",
+        "- Set a param only if the template takes it; leave every other param null.",
+        "- `text-matches` takes a JavaScript regular expression. Escape it properly; prefer word boundaries (\\b). Leave its `fields` null — that searches every text field — unless the sentence names particular fields.",
+        "- Trigger: `schedule` for anything about time passing (dates, staleness, \"every Monday\", \"daily\"); `event` with `on: apply` to check each edit, `on: publish` to check after publishing; `manual` only if the person asked to run it themselves. Schedules are UTC; default to hour 6, and weekday 1 (Monday) for weekly. For `event` leave every/hour/weekday null; for `schedule` leave `on` null.",
+        "- Scope narrows the agent to pages (slugs) or block types only when the sentence says so.",
+        "- `name`: 2–4 words. `brief`: the job in one sentence. Write both in the `language` you are given, whatever language the sentence or the site is in.",
+        "- `severity`: `error` only for something broken or wrong in public; `warning` by default.",
+        "- If none of the templates can check what is asked — it needs traffic data, an outside service, judgement about tone, or anything not in the page content — set `cannot` to one sentence saying what is missing, and return an empty `detect`. Never approximate the request with a template that checks something else."
+    ].join("\n");
+}
+/** What the model needs to name real fields: each block type on the site and its field names. */
+export function siteSummary(pages) {
+    const manifest = buildBlockManifest();
+    const blocks = new Map();
+    for (const page of pages) {
+        for (const entry of walkPageFields(page, manifest)) {
+            const name = entry.path.split(".").pop().replace(/\[\d+\]/g, "[]");
+            let fields = blocks.get(entry.blockType);
+            if (!fields)
+                blocks.set(entry.blockType, (fields = new Map()));
+            if (fields.size >= MAX_FIELDS_PER_TYPE || fields.has(name))
+                continue;
+            // One sample value, so "the date field" can be told from "the date label".
+            fields.set(name, fieldText(entry.value).slice(0, 40));
+        }
+    }
+    return {
+        pages: pages.map((page) => page.slug).slice(0, 100),
+        blocks: Object.fromEntries([...blocks].map(([type, fields]) => [type, [...fields].map(([name, sample]) => (sample ? `${name} (e.g. "${sample}")` : name))]))
+    };
+}
+function dropNulls(value) {
+    if (Array.isArray(value))
+        return value.map(dropNulls);
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).filter(([, v]) => v !== null).map(([k, v]) => [k, dropNulls(v)]));
+    }
+    return value;
+}
+/** `custom:` + the name, lowercased and dashed, made unique among the site's agents. */
+export function customIdFor(name, taken) {
+    const base = name
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 40) || "agent";
+    let id = `custom:${base}`;
+    for (let n = 2; taken.has(id); n++)
+        id = `custom:${base}-${n}`;
+    return id;
+}
+async function callModel(client, model, user) {
+    const response = await client.messages.create({
+        model,
+        max_tokens: 2048,
+        system: systemPrompt(),
+        output_config: { format: { type: "json_schema", schema: DRAFT_JSON_SCHEMA } },
+        messages: [{ role: "user", content: user }]
+    }, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+    if (response.stop_reason === "max_tokens")
+        throw new Error("the draft was cut off");
+    const text = response.content.find((block) => block.type === "text")?.text ?? "";
+    if (!text.trim())
+        throw new Error("the model returned nothing");
+    return JSON.parse(text);
+}
+/** The editor's languages. The name and brief are written in the reader's, not guessed from the sentence. */
+const LANGUAGES = { en: "English", de: "German" };
+export async function draftAgentSpec(args) {
+    const sentence = args.sentence.trim().slice(0, MAX_SENTENCE);
+    const client = args.client ?? getAnthropicClient();
+    const model = args.model ?? defaultModelLookup().anthropic.balanced;
+    const site = await resolveSiteAgents(args.scopeKey);
+    const taken = new Set(site.agents.map((agent) => agent.agentId));
+    const summary = siteSummary([...getSessionDraft(args.scopeKey).values()]);
+    const language = LANGUAGES[args.locale ?? "en"] ?? "English";
+    let user = JSON.stringify({ sentence, language, site: summary });
+    let lastError = "";
+    // One retry, with the reason, when the draft does not compile: the model
+    // usually fixes a bad regex or a param the template does not take.
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const raw = await callModel(client, model, user);
+        if (typeof raw.cannot === "string" && raw.cannot.trim()) {
+            return { ok: false, reason: "cannot", message: raw.cannot.trim() };
+        }
+        const cleaned = dropNulls(raw);
+        delete cleaned.cannot;
+        const name = typeof cleaned.name === "string" ? cleaned.name : "Agent";
+        const parsed = parseCustomSpec({ ...cleaned, id: customIdFor(name, taken) });
+        if (parsed.ok) {
+            try {
+                compileSpec(parsed.spec);
+                return { ok: true, spec: parsed.spec };
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error.message : String(error);
+            }
+        }
+        else {
+            lastError = parsed.error;
+        }
+        args.log?.warn({ attempt, error: lastError }, "[agents] drafted spec did not compile");
+        user = JSON.stringify({ sentence, language, site: summary, previousAttempt: raw, error: lastError });
+    }
+    return { ok: false, reason: "invalid", message: lastError };
+}

package/dist/agents/edit-safety-resolve.d.ts

@@ -0,0 +1,70 @@
+import type { PageDoc } from "@avocadostudio-ai/shared";
+import type { InboxItemRecord } from "../durable/types.ts";
+import { type Logger } from "../logger.ts";
+export type EditSafetyDecision = "revert" | "intended";
+export type RevertOutcome = {
+    applied: number;
+    /** Issues skipped because the field changed after the edit. */
+    changedSince: number;
+    failed: Array<{
+        path?: string;
+        blockId?: string;
+        error: string;
+    }>;
+    previewVersion?: number;
+};
+export type ResolveResult = {
+    ok: true;
+    item: InboxItemRecord;
+    revert?: RevertOutcome;
+} | {
+    ok: false;
+    code: number;
+    error: string;
+};
+/**
+ * Each page a revert touched, as it was before and a fingerprint of it after —
+ * what "Undo" needs to put the revert back, and to refuse when somebody has
+ * changed the page since. Stored on the alert, never sent to the editor.
+ */
+export type RevertedPages = Record<string, {
+    before: PageDoc | null;
+    afterHash: string;
+}>;
+/** A page's content, without the timestamp every write restamps. */
+export declare function contentHash(page: PageDoc | null): string;
+export declare function resolveEditSafetyAlert(args: {
+    scopeKey: string;
+    itemId: string;
+    decision: EditSafetyDecision;
+    resolvedBy?: string;
+    log?: Logger;
+}): Promise<ResolveResult>;
+/** The stored page snapshots are the server's business; the editor never needs them. */
+export declare function withoutPages(item: InboxItemRecord): InboxItemRecord;
+export type UndoRevertResult = {
+    ok: true;
+    item: InboxItemRecord;
+    previewVersion: number;
+    slugs: string[];
+} | {
+    ok: false;
+    code: number;
+    error: string;
+    changedSlugs?: string[];
+};
+/**
+ * Undo "Put it back": the pages go back to what the edit left, and the alert
+ * reopens — the damage is back, so is the publish hold, and the person can
+ * decide again (site-ops-agents.md SO-08, "Undo everywhere").
+ *
+ * All or nothing, and only while every page the revert touched is exactly as
+ * the revert left it. A page somebody has edited since is not rolled back
+ * under them; the answer names it and points at History instead.
+ */
+export declare function undoRevert(args: {
+    scopeKey: string;
+    itemId: string;
+    by?: string;
+    log?: Logger;
+}): Promise<UndoRevertResult>;