@avocadostudio-ai/orchestrator-core 0.22.0 → 0.23.0

package/dist/chat/anthropic-planner.js

@@ -9,6 +9,7 @@ import { buildPlannerSchemaContext, extractUpdatePropsFieldDraftsFromPlanBuffer,
 import { buildEditPlanJsonSchema, intentJsonSchema } from "./plan-json-schema.js";
 import { extractUsage, ZERO_USAGE } from "../telemetry/usage.js";
 import { anthropicSystemPromptWithCache, anthropicSegmentedSystemPromptWithCache, anthropicToolWithCache, ANTHROPIC_FINE_GRAINED_STREAM_HEADERS } from "./anthropic-cache.js";
+import { minimalThinkingParams, supportsForcedToolChoice } from "./anthropic-model-caps.js";
 import { executeToolCall } from "../tools/runtime.js";
 import { DEFERRABLE_IMAGE_TOOLS } from "./chat-pipeline-shared.js";
 import { buildFullPageTranslationChecklist } from "./chat-pipeline-translation.js";
@@ -111,7 +112,7 @@ function salvageTruncatedPlan(args) {
 // ANTHROPIC_API_KEY isn't set yet.
 // ---------------------------------------------------------------------------
 let _anthropicSingleton = null;
-function getAnthropicClient() {
+export function getAnthropicClient() {
     if (!_anthropicSingleton) {
         _anthropicSingleton = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
     }
@@ -252,6 +253,19 @@ export async function generatePlanWithAnthropic(args) {
         attachmentCount: args.contextPack.attachments?.length,
         attachmentImages: args.contextPack.attachments?.filter((attachment) => attachment.kind === "image").map(({ url, name }) => ({ url, name })),
     });
+    // Sonnet 5.5 / Opus 5.5 reject a forced tool_choice, so on them the planner
+    // can only ask for the submit_edit_plan call rather than require it. The
+    // request goes in the uncached tail; it is constant per model, and a model
+    // switch misses the cache anyway.
+    const forcedToolChoiceOk = supportsForcedToolChoice(args.model);
+    if (!forcedToolChoiceOk) {
+        systemSegments.dynamic = [
+            systemSegments.dynamic,
+            "RESPONSE CHANNEL: finish by calling the submit_edit_plan tool exactly once with the complete EditPlan. " +
+                "This includes questions and clarifications (intent needs_clarification) and answers that change nothing. " +
+                "Never reply in plain text instead of calling submit_edit_plan."
+        ].filter((part) => part.trim().length > 0).join("\n\n");
+    }
     // Stable prefix carries cache_control; dynamic tail is sent as a second
     // text block without it, so per-request flags don't bust the cached prefix.
     const cachedSystem = anthropicSegmentedSystemPromptWithCache(systemSegments);
@@ -413,9 +427,13 @@ export async function generatePlanWithAnthropic(args) {
         ? { type: "adaptive", display: "summarized" }
         : undefined;
     const effortParam = thinkingParam ? args.thinking.effort : undefined;
+    // "Thinking OFF" is spelled per model: nothing on older models, `between_tools`
+    // on Sonnet 5.5, low effort on Opus 5.5 (which always thinks). See
+    // anthropic-model-caps.ts.
+    const minimalThinking = minimalThinkingParams(args.model);
     // Adaptive thinking counts thinking tokens against max_tokens; give headroom so
     // the actual response isn't truncated. Effort (not max_tokens) governs spend.
-    const baseMaxTokens = thinkingParam ? 16000 : 8192;
+    const baseMaxTokens = thinkingParam || minimalThinking.output_config ? 16000 : 8192;
     // Whole-page translations and rewrites re-emit every translatable string on the
     // page inside an op envelope, so their output length scales with the page — a
     // flat budget truncates them.
@@ -445,15 +463,34 @@ export async function generatePlanWithAnthropic(args) {
     // decoding fallback (thinking OFF) sets output_config.format instead.
     const thinkingRequestParams = thinkingParam
         ? { thinking: thinkingParam, output_config: { effort: effortParam } }
-        : {};
+        : minimalThinking;
+    // Where thinking is off, the submit_edit_plan call is forced — on models that
+    // allow it. Sonnet 5.5 / Opus 5.5 400 on a forced tool_choice, so they get
+    // `auto` plus the RESPONSE CHANNEL instruction in the system prompt.
+    const forcedSubmitChoice = forcedToolChoiceOk
+        ? { type: "tool", name: "submit_edit_plan" }
+        : { type: "auto" };
     // Plan-first review mode forces the submit_edit_plan tool so the model cannot
     // emit free-form prose (which the text-only fallback wraps as
     // needs_clarification). Combined with the narrowed intent enum, this
     // guarantees a reviewable edit_plan. Safe here because planFirstMode also
     // disables thinking above, and forced tool_choice is incompatible with thinking.
-    const submitToolChoice = planFirstMode
-        ? { type: "tool", name: "submit_edit_plan" }
-        : { type: "auto" };
+    // Where forcing is unavailable, the tool loop below asks once more instead.
+    const submitToolChoice = planFirstMode ? forcedSubmitChoice : { type: "auto" };
+    // On a model that cannot be forced, a prose-only reply is the model choosing
+    // to talk rather than plan — the same thing the auto/thinking path has always
+    // wrapped as needs_clarification, so it gets the same treatment.
+    const textOnlyPlan = (text) => {
+        const trimmed = text.trim();
+        if (forcedToolChoiceOk || trimmed.length <= MIN_MEANINGFUL_RESPONSE_LENGTH)
+            return null;
+        emitThinkingEnd();
+        return {
+            plan: { intent: "needs_clarification", summary_for_user: trimmed, change_log: [], ops: [] },
+            usage,
+            schemaContext: schemaContext.meta
+        };
+    };
     // Track thinking lifecycle for callbacks (Path 1 tool-loop and Path 2 stream)
     let thinkingStartedAt = null;
     const emitThinkingStart = () => {
@@ -709,6 +746,15 @@ export async function generatePlanWithAnthropic(args) {
                     if (parsed)
                         break;
                 }
+                // Plan-first review needs a plan, and this model could not be forced to
+                // submit one. Ask once, appending rather than editing the history so the
+                // reply's thinking blocks stay valid for the next request.
+                if (planFirstMode && !forcedToolChoiceOk && turn < maxToolTurns - 1 && response.content.length > 0) {
+                    args.log?.warn({ event: "anthropic_planner_submit_nudge", model: args.model, turn }, "Anthropic planner: no submit_edit_plan call in plan-first mode — asking again");
+                    loopMessages.push({ role: "assistant", content: response.content });
+                    loopMessages.push({ role: "user", content: "Call the submit_edit_plan tool now with your complete EditPlan." });
+                    continue;
+                }
                 // Model responded with text only (no tool call). If we have meaningful
                 // text content, treat it as an "info" response rather than discarding it.
                 const trimmed = raw.trim();
@@ -845,9 +891,7 @@ export async function generatePlanWithAnthropic(args) {
                 max_tokens: plannerStreamMaxTokens,
                 system: cachedSystem,
                 tools: [anthropicToolWithCache(submitPlanToolDef)],
-                tool_choice: thinkingParam
-                    ? { type: "auto" }
-                    : { type: "tool", name: "submit_edit_plan" },
+                tool_choice: thinkingParam ? { type: "auto" } : forcedSubmitChoice,
                 messages: [
                     ...historyMessages,
                     { role: "user", content: userContent }
@@ -972,6 +1016,11 @@ export async function generatePlanWithAnthropic(args) {
                     throw new Error("Model response was truncated (max_tokens reached)");
                 parsed = salvaged;
             }
+            if (!parsed) {
+                const textOnly = textOnlyPlan(textBuf);
+                if (textOnly)
+                    return textOnly;
+            }
         }
         else {
             const response = await client.messages.create({
@@ -979,9 +1028,7 @@ export async function generatePlanWithAnthropic(args) {
                 max_tokens: plannerMaxTokens,
                 system: cachedSystem,
                 tools: [anthropicToolWithCache(submitPlanToolDef)],
-                tool_choice: thinkingParam
-                    ? { type: "auto" }
-                    : { type: "tool", name: "submit_edit_plan" },
+                tool_choice: thinkingParam ? { type: "auto" } : forcedSubmitChoice,
                 messages: [
                     ...historyMessages,
                     { role: "user", content: userContent }
@@ -1019,6 +1066,11 @@ export async function generatePlanWithAnthropic(args) {
                         catch { /* fall through */ }
                     }
                 }
+                if (!parsed) {
+                    const textOnly = textOnlyPlan(raw);
+                    if (textOnly)
+                        return textOnly;
+                }
             }
         }
     }
@@ -1034,7 +1086,9 @@ export async function generatePlanWithAnthropic(args) {
                     model: args.model,
                     max_tokens: plannerMaxTokens,
                     system: cachedSystem,
+                    ...minimalThinking,
                     output_config: {
+                        ...minimalThinking.output_config,
                         format: { type: "json_schema", schema: buildEditPlanJsonSchema({ planFirstMode }) }
                     },
                     messages: [
@@ -1090,9 +1144,7 @@ export async function generatePlanWithAnthropic(args) {
                 max_tokens: plannerMaxTokens,
                 system: cachedSystem,
                 tools: [anthropicToolWithCache(submitPlanToolDef)],
-                tool_choice: thinkingParam
-                    ? { type: "auto" }
-                    : { type: "tool", name: "submit_edit_plan" },
+                tool_choice: thinkingParam ? { type: "auto" } : forcedSubmitChoice,
                 messages: [
                     ...historyMessages,
                     { role: "user", content: userContent }
@@ -1130,6 +1182,11 @@ export async function generatePlanWithAnthropic(args) {
                         catch { /* fall through */ }
                     }
                 }
+                if (!parsed) {
+                    const textOnly = textOnlyPlan(raw);
+                    if (textOnly)
+                        return textOnly;
+                }
             }
         }
     }

package/dist/chat/chat-pipeline.js

@@ -63,6 +63,8 @@ import { runVariationPipeline, getCachedVariations } from "./variation-pipeline.
 import { validateAndStripHallucinatedProps } from "./hallucination-validator.js";
 import { validateChangelogCoverage } from "./changelog-coverage-validator.js";
 import { generateAltTextFromVision, parseAltPathForOp } from "./vision-alt-generator.js";
+import { checkEditSafety, pagesBefore, summarizeReport } from "../agents/edit-safety-runner.js";
+import { recordOutcome, siteFactsForPlanner } from "../agents/learning.js";
 /**
  * Whether the CURRENT message plausibly depends on prior conversation turns — an
  * anaphoric or very terse follow-up ("make it bigger", "undo", "do that again").
@@ -432,6 +434,16 @@ export async function runChatPipeline(ctx, body, options) {
             return { code: 409, payload: { error: "pending plan mismatch" } };
         }
         await clearPendingPlan(body.session, "discarded");
+        // Stopping a held plan is a person rejecting a proposal (SO-11).
+        await recordOutcome({
+            scopeKey: body.session,
+            traceId: existing.id,
+            slug: existing.effectiveSlug,
+            request: existing.originalMessage ?? existing.summary,
+            proposed: existing.plan.ops,
+            outcome: "rejected",
+            log: ctx.log
+        });
         return {
             code: 200,
             payload: {
@@ -503,7 +515,9 @@ export async function runChatPipeline(ctx, body, options) {
      */
     const siteLocales = resolveSiteLocales(getSiteConfig(body.session), Array.from(getSessionDraft(body.session).keys()));
     const siteLanguagesLine = siteLocales ? siteLanguagesContextLine(siteLocales, body.slug) : undefined;
+    const siteFacts = await siteFactsForPlanner(body.session, ctx.log);
     const siteContextBlock = buildSiteContextBlock({
+        ...(siteFacts.length > 0 ? { siteFacts } : {}),
         sitePurpose: body.sitePurpose,
         siteHosting: body.siteHosting,
         businessContext: body.businessContext,
@@ -2255,6 +2269,12 @@ export async function runChatPipeline(ctx, body, options) {
             };
         }
         const previous = getPage(body.session, effectiveSlug);
+        // Every page the plan names, before it is applied — Edit safety checks each
+        // of them, not only the page this turn was about. A streamed turn has
+        // already applied its ops, and hands over the snapshots it took on the way.
+        const editSafetyBefore = optionsOverride?.preApplied && optionsOverride.rollbackSnapshots
+            ? new Map(optionsOverride.rollbackSnapshots)
+            : pagesBefore(resolvedPlan.ops, (slug) => getPage(body.session, slug), [effectiveSlug]);
         const hasCreatePage = resolvedPlan.ops.some((op) => op.op === "create_page");
         if (!previous && !hasCreatePage) {
             return {
@@ -2950,6 +2970,16 @@ export async function runChatPipeline(ctx, body, options) {
              */
             if (optionsOverride?.approvedPlanId) {
                 await clearPendingPlan(body.session, "approved", optionsOverride.approvedPlanId);
+                await recordOutcome({
+                    scopeKey: body.session,
+                    traceId: optionsOverride.approvedPlanId,
+                    slug: effectiveSlug,
+                    request: body.message ?? resolvedPlan.summary_for_user,
+                    proposed: resolvedPlan.ops,
+                    outcome: "accepted",
+                    applied: resolvedPlan.ops,
+                    log: ctx.log
+                });
             }
             else {
                 await clearPendingPlan(body.session, "discarded");
@@ -2969,9 +2999,27 @@ export async function runChatPipeline(ctx, body, options) {
                 opTypes: resolvedPlan.ops.map((op) => op.op),
                 opCount: resolvedPlan.ops.length,
                 source: "chat",
+                actor: { kind: "chat" },
                 snapshot: versionSnapshot ? structuredClone(versionSnapshot) : null
             });
             schedulePersistState(ctx.log);
+            // Every page the plan touched, each diffed against itself before the
+            // turn. A created or removed page has no before or no after, and is left
+            // to the destructive-action gate.
+            if (skipApply && undoSnapshot && !editSafetyBefore.has(effectiveSlug))
+                editSafetyBefore.set(effectiveSlug, undoSnapshot);
+            const editSafetyReport = editSafetyBefore.size > 0
+                ? await checkEditSafety({
+                    scopeKey: body.session,
+                    before: editSafetyBefore,
+                    afterOf: (slug) => getPage(body.session, slug) ?? null,
+                    ops: resolvedPlan.ops,
+                    source: "chat",
+                    ...(body.message ? { request: body.message } : {}),
+                    traceId: chatRequestId,
+                    log: ctx.log
+                })
+                : null;
             const focusBlockId = pickFocusBlockId(resolvedPlan.ops);
             const aiInsightChanges = buildAiInsightChanges({ plan: resolvedPlan, message: plannerMessage });
             const metaChangeLogEntries = buildMetaChangeLogEntries(resolvedPlan.ops);
@@ -3039,6 +3087,7 @@ export async function runChatPipeline(ctx, body, options) {
                         focusBlockId,
                         updatedSlug,
                         undoSlug: undoTargetSlug,
+                        ...(editSafetyReport ? { editSafety: summarizeReport(editSafetyReport) } : {}),
                         plannerSource: source,
                         modelUsed,
                         modelKey
@@ -4604,7 +4653,11 @@ export async function runChatPipeline(ctx, body, options) {
             : `streamed apply covered ${streamApplyState.processedCount} of ${initialPlan.ops.length} planned ops`);
     }
     const initialOutcome = await respondFromPlan(initialPlan, plannerSource, applyMode, streamedApplyComplete
-        ? { preApplied: true, undoSnapshot: streamApplyState.rollbackSnapshots.get(effectiveSlug) ?? undefined }
+        ? {
+            preApplied: true,
+            undoSnapshot: streamApplyState.rollbackSnapshots.get(effectiveSlug) ?? undefined,
+            rollbackSnapshots: new Map(streamApplyState.rollbackSnapshots)
+        }
         : undefined, "full_llm");
     if (initialOutcome.done)
         return initialOutcome.response;

package/dist/chat/model-defaults.js

@@ -33,9 +33,12 @@ export const defaultModelLookup = () => ({
     },
     anthropic: {
         fast: process.env.ANTHROPIC_MODEL_FAST ?? "claude-haiku-4-5-20251001",
-        balanced: process.env.ANTHROPIC_MODEL_BALANCED ?? "claude-sonnet-5",
-        reasoning: process.env.ANTHROPIC_MODEL_REASONING ?? "claude-sonnet-5",
-        codex: process.env.ANTHROPIC_MODEL_CODEX ?? "claude-opus-4-8"
+        // Sonnet 5.5 / Opus 5.5 reject a forced tool_choice and a disabled thinking
+        // block; the planner adapts per model (see anthropic-model-caps.ts), so an
+        // override back to Sonnet 5 or Opus 4.8 still works.
+        balanced: process.env.ANTHROPIC_MODEL_BALANCED ?? "claude-sonnet-5-5",
+        reasoning: process.env.ANTHROPIC_MODEL_REASONING ?? "claude-sonnet-5-5",
+        codex: process.env.ANTHROPIC_MODEL_CODEX ?? "claude-opus-5-5"
     },
     gemini: {
         fast: process.env.GOOGLE_GENAI_MODEL_FAST ?? "gemini-3.5-flash-lite",

package/dist/checks/rules-draft.d.ts

@@ -1,2 +1,7 @@
-import type { CheckRule } from "./types.ts";
+import type { CheckContext, CheckRule } from "./types.ts";
+export declare const TITLE_MIN = 20;
+export declare const TITLE_MAX = 60;
+export declare const DESCRIPTION_MIN = 70;
+export declare const DESCRIPTION_MAX = 160;
+export declare function effectiveTitle(page: CheckContext["page"]): string;
 export declare const DRAFT_RULES: CheckRule[];

package/dist/checks/rules-draft.js

@@ -1,5 +1,6 @@
 import { IMAGE_PLACEHOLDER, isKnownRoute, normalizeLinkPath, parseLink, toAltPath } from "@avocadostudio-ai/shared";
 import { fieldText, groupByBlock } from "./field-walk.js";
+import { I18N_RULES } from "./rules-i18n.js";
 /*
  * The eleven-ish draft-tier rules. Each is a pure function; none does IO.
  *
@@ -9,12 +10,12 @@ import { fieldText, groupByBlock } from "./field-walk.js";
  *   warning — this is very likely wrong
  *   info    — worth a look, and safe to ignore forever
  */
-const TITLE_MIN = 20;
-const TITLE_MAX = 60;
-const DESCRIPTION_MIN = 70;
-const DESCRIPTION_MAX = 160;
+export const TITLE_MIN = 20;
+export const TITLE_MAX = 60;
+export const DESCRIPTION_MIN = 70;
+export const DESCRIPTION_MAX = 160;
 const THIN_CONTENT_CHARS = 120;
-function effectiveTitle(page) {
+export function effectiveTitle(page) {
     return (page.meta?.title ?? page.title ?? "").trim();
 }
 function nonEmpty(value) {
@@ -389,7 +390,7 @@ const altMissing = {
                     key: `${image.blockId}:${image.path}`,
                     title: `Image has no alt text`,
                     detail: `${image.label ?? image.path} is set but its alt text is empty.`,
-                    evidence: evidenceFor(alt)
+                    evidence: { ...evidenceFor(alt), imageUrl: String(image.value) }
                 });
             }
         }
@@ -435,5 +436,7 @@ export const DRAFT_RULES = [
     internalLinkDead,
     fileLinkUnknown,
     altMissing,
-    unfinished
+    unfinished,
+    // Translation drift's rules: silent on a site with one language.
+    ...I18N_RULES
 ];

package/dist/checks/rules-i18n.d.ts

@@ -0,0 +1,25 @@
+import { type BlockInstance, type PageDoc } from "@avocadostudio-ai/shared";
+import type { CheckContext, CheckRule } from "./types.ts";
+type Pair = {
+    page: PageDoc;
+    source: PageDoc;
+    locale: string;
+    sourceLocale: string;
+};
+/** The source-language counterpart of a translated page, or null for a page that is its own source. */
+export declare function translationPair(ctx: Pick<CheckContext, "page" | "site">): Pair | null;
+/**
+ * Pair blocks by type in order: each block of the translation takes the next
+ * unpaired source block of the same type. A block with no partner is what
+ * i18n.structure reports.
+ */
+export declare function pairBlocks(source: BlockInstance[], translation: BlockInstance[]): {
+    pairs: {
+        source: BlockInstance;
+        translation: BlockInstance;
+    }[];
+    missing: BlockInstance[];
+    extra: BlockInstance[];
+};
+export declare const I18N_RULES: CheckRule[];
+export {};

package/dist/checks/rules-i18n.js

@@ -0,0 +1,193 @@
+import { counterpartRoute, groupRoutesByLocale, localeOfRoute } from "@avocadostudio-ai/shared";
+import { fieldText, walkPageFields } from "./field-walk.js";
+/*
+ * Translation drift (site-ops-agents.md §1, §8 item 13): a page in another
+ * language that no longer says what its source-language page says.
+ *
+ * A translated page is compared with its counterpart in the site's source
+ * language — the unprefixed root, or the declared default. Blocks are paired
+ * by position and type, not by id: a translation made by copying a page gets
+ * new block ids, but keeps the source's order.
+ *
+ * Three rules, all deterministic, none needing history:
+ *  - i18n.structure    — the pages no longer have the same blocks: one was
+ *                        added to the source and never to the translation,
+ *                        or the other way round;
+ *  - i18n.untranslated — a text field still holds the source's words,
+ *                        copied and never translated;
+ *  - i18n.source-newer — the source page was edited after the translation
+ *                        was last touched, so something may be missing.
+ *
+ * A site with one language, or none detectable from its slugs, gets nothing.
+ */
+/** Text shorter than this is too often the same in both languages (a name, "FAQ", "OK"). */
+const UNTRANSLATED_MIN_CHARS = 25;
+/** The source is newer by at least this much before it counts: saves and seeds land within seconds. */
+const SOURCE_NEWER_MARGIN_MS = 60 * 60 * 1000;
+const FINDINGS_PER_PAGE = 20;
+/** The source-language counterpart of a translated page, or null for a page that is its own source. */
+export function translationPair(ctx) {
+    const lookup = ctx.site.page;
+    if (!lookup)
+        return null;
+    const routes = groupRoutesByLocale(ctx.site.slugs);
+    if (!routes)
+        return null;
+    const declared = ctx.site.config.defaultLocale?.trim().toLowerCase().split("-")[0];
+    const sourceLocale = declared && routes.byLocale[declared] ? declared : routes.locales[0];
+    if (!sourceLocale)
+        return null;
+    const locale = localeOfRoute(ctx.page.slug, routes);
+    if (!locale || locale === sourceLocale)
+        return null;
+    const sourceSlug = counterpartRoute(ctx.page.slug, sourceLocale, routes);
+    const source = sourceSlug ? lookup(sourceSlug) : undefined;
+    if (!source)
+        return null;
+    return { page: ctx.page, source, locale, sourceLocale };
+}
+/**
+ * Pair blocks by type in order: each block of the translation takes the next
+ * unpaired source block of the same type. A block with no partner is what
+ * i18n.structure reports.
+ */
+export function pairBlocks(source, translation) {
+    const pairs = [];
+    const used = new Set();
+    const unmatched = [];
+    let cursor = 0;
+    for (const block of translation) {
+        let found = -1;
+        for (let i = cursor; i < source.length; i++) {
+            if (!used.has(i) && source[i].type === block.type) {
+                found = i;
+                break;
+            }
+        }
+        if (found === -1) {
+            unmatched.push(block);
+            continue;
+        }
+        used.add(found);
+        cursor = found + 1;
+        pairs.push({ source: source[found], translation: block });
+    }
+    const missing = source.filter((_, i) => !used.has(i));
+    return { pairs, missing, extra: unmatched };
+}
+function label(block) {
+    const props = block.props;
+    for (const key of ["heading", "title", "label"]) {
+        const value = props[key];
+        if (typeof value === "string" && value.trim())
+            return `${block.type} “${value.trim().slice(0, 40)}”`;
+    }
+    return block.type;
+}
+const structure = {
+    id: "i18n.structure",
+    agent: "translation-drift",
+    severity: "warning",
+    run: (ctx) => {
+        const pair = translationPair(ctx);
+        if (!pair)
+            return [];
+        const { missing, extra } = pairBlocks(pair.source.blocks, pair.page.blocks);
+        const out = [];
+        if (missing.length > 0) {
+            out.push({
+                key: "missing",
+                title: `${missing.length} block${missing.length === 1 ? "" : "s"} on ${pair.source.slug} ${missing.length === 1 ? "is" : "are"} missing here`,
+                detail: `Not on this ${pair.locale} page: ${missing.map(label).join(", ")}.`,
+                evidence: { source: "draft", locale: pair.locale }
+            });
+        }
+        if (extra.length > 0) {
+            out.push({
+                key: "extra",
+                severity: "info",
+                title: `${extra.length} block${extra.length === 1 ? "" : "s"} here ${extra.length === 1 ? "is" : "are"} not on ${pair.source.slug}`,
+                detail: `Only on this ${pair.locale} page: ${extra.map(label).join(", ")}. Removed from the source, or added here on purpose?`,
+                evidence: { source: "draft", locale: pair.locale }
+            });
+        }
+        return out;
+    }
+};
+/** Words, not a URL, a number or a code: something a translator would have changed. */
+function isTranslatableText(text) {
+    if (text.length < UNTRANSLATED_MIN_CHARS)
+        return false;
+    if (/^(https?:\/\/|\/|#|mailto:|tel:)/i.test(text))
+        return false;
+    return (text.match(/\p{L}/gu) ?? []).length >= 12 && /\s/.test(text);
+}
+const untranslated = {
+    id: "i18n.untranslated",
+    agent: "translation-drift",
+    severity: "warning",
+    run: (ctx) => {
+        const pair = translationPair(ctx);
+        if (!pair)
+            return [];
+        const { pairs } = pairBlocks(pair.source.blocks, pair.page.blocks);
+        const sourceFields = new Map();
+        for (const entry of walkPageFields(pair.source, ctx.manifest)) {
+            const list = sourceFields.get(entry.blockId) ?? [];
+            list.push(entry);
+            sourceFields.set(entry.blockId, list);
+        }
+        const out = [];
+        for (const { source, translation } of pairs) {
+            const bySourcePath = new Map((sourceFields.get(source.id) ?? []).map((f) => [f.path, f]));
+            for (const field of ctx.fields) {
+                if (field.blockId !== translation.id || (field.kind !== "text" && field.kind !== "richtext"))
+                    continue;
+                const text = fieldText(field.value).replace(/\s+/g, " ").trim();
+                const sourceText = fieldText(bySourcePath.get(field.path)?.value).replace(/\s+/g, " ").trim();
+                if (!text || text !== sourceText || !isTranslatableText(text))
+                    continue;
+                out.push({
+                    key: `${field.blockId}:${field.path}`,
+                    title: `Still in the source language: ${field.label ?? field.path}`,
+                    detail: `“${text.slice(0, 80)}${text.length > 80 ? "…" : ""}” is the same as on ${pair.source.slug}.`,
+                    evidence: {
+                        source: "draft",
+                        blockId: field.blockId,
+                        blockType: field.blockType,
+                        ...(field.blockLabel ? { blockLabel: field.blockLabel } : {}),
+                        path: field.path,
+                        locale: pair.locale,
+                        sourceText: text
+                    }
+                });
+                if (out.length >= FINDINGS_PER_PAGE)
+                    return out;
+            }
+        }
+        return out;
+    }
+};
+const sourceNewer = {
+    id: "i18n.source-newer",
+    agent: "translation-drift",
+    severity: "info",
+    run: (ctx) => {
+        const pair = translationPair(ctx);
+        if (!pair)
+            return [];
+        const sourceAt = Date.parse(pair.source.updatedAt);
+        const pageAt = Date.parse(pair.page.updatedAt);
+        if (Number.isNaN(sourceAt) || Number.isNaN(pageAt) || sourceAt - pageAt < SOURCE_NEWER_MARGIN_MS)
+            return [];
+        const day = (at) => new Date(at).toISOString().slice(0, 10);
+        return [
+            {
+                title: `${pair.source.slug} was edited after this page`,
+                detail: `The source page changed on ${day(sourceAt)}; this ${pair.locale} page was last changed on ${day(pageAt)}. Check it still says the same.`,
+                evidence: { source: "draft", locale: pair.locale }
+            }
+        ];
+    }
+};
+export const I18N_RULES = [structure, untranslated, sourceNewer];

package/dist/checks/run-checks.d.ts

@@ -1,5 +1,5 @@
 import type { BlockManifest, PageDoc, SiteConfig } from "@avocadostudio-ai/shared";
-import type { CheckRunRecord, CheckRunTrigger, DurableStore } from "../durable/types.ts";
+import type { CheckRunRecord, CheckRunTrigger, DurableStore, FindingInput } from "../durable/types.ts";
 import type { CheckRule, SiteAsset } from "./types.ts";
 /**
  * The fingerprint: identity of a problem, not of an occurrence of it.
@@ -35,8 +35,23 @@ export type RunChecksArgs = {
      */
     assets?: SiteAsset[];
     rules?: CheckRule[];
+    /** The ledger's agent. Defaults to the single rule's agent, else "checks". */
+    agent?: string;
     store?: DurableStore;
     runId?: string;
     now?: () => number;
 };
+export type EvaluatedChecks = {
+    findings: FindingInput[];
+    scannedSlugs: string[];
+    /** The first rule that threw, if any did. The others still ran. */
+    error?: string;
+};
+/**
+ * The rules over a site, with no store and no run ledger — pure in-memory work
+ * over the pages given. `runDraftChecks` records what this returns; the first
+ * run's backtest and the re-check before a fix is applied use it directly,
+ * because neither may write a finding.
+ */
+export declare function evaluateDraftChecks(args: Omit<RunChecksArgs, "store" | "runId" | "now" | "trigger">): EvaluatedChecks;
 export declare function runDraftChecks(args: RunChecksArgs): Promise<CheckRunRecord>;