@actalk/inkos-core 1.4.1 → 1.5.0-canary.47.1

package/dist/agents/composer.js

@@ -3,23 +3,35 @@ import { dirname, join } from "node:path";
 import { BaseAgent } from "./base.js";
 import { ContextPackageSchema, } from "../models/input-governance.js";
 import { parseChapterSummariesMarkdown, retrieveMemorySelection, } from "../utils/memory-retrieval.js";
-import { buildGovernedRuleStack, buildGovernedTrace, } from "../utils/context-assembly.js";
+import { buildGovernedRuleStack, buildGovernedTrace, isProtectedContextSource, } from "../utils/context-assembly.js";
 import { writeGovernedRuntimeArtifacts } from "../utils/runtime-writer.js";
+import { estimateTextTokens } from "../llm/provider.js";
 export async function composeGovernedChapter(input) {
     const storyDir = join(input.bookDir, "story");
     const runtimeDir = join(storyDir, "runtime");
     await mkdir(runtimeDir, { recursive: true });
-    const selectedContext = await collectSelectedContext(storyDir, input.plan, input.book.language ?? "zh");
-    const contextPackage = ContextPackageSchema.parse({
+    const selectedContext = await collectSelectedContext(storyDir, input.plan, input.book.language ?? "zh", input.outlineSectionSelector);
+    const initialContextPackage = ContextPackageSchema.parse({
         chapter: input.chapterNumber,
         selectedContext,
     });
+    const budgeted = await applyContextBudgetIfNeeded({
+        contextPackage: initialContextPackage,
+        chapterNumber: input.chapterNumber,
+        goal: input.plan.intent.goal,
+        language: input.book.language ?? "zh",
+        contextBudget: input.contextBudget,
+        compiler: input.compressibleContextCompiler,
+        onContextCompression: input.onContextCompression,
+    });
+    const contextPackage = budgeted.contextPackage;
     const ruleStack = buildGovernedRuleStack(input.plan, input.chapterNumber);
     const trace = buildGovernedTrace({
         chapterNumber: input.chapterNumber,
         plan: input.plan,
         contextPackage,
         composerInputs: [input.plan.runtimePath],
+        notes: budgeted.notes,
     });
     const { contextPath, ruleStackPath, tracePath, } = await writeGovernedRuntimeArtifacts({
         runtimeDir,
@@ -37,15 +49,279 @@ export async function composeGovernedChapter(input) {
         tracePath,
     };
 }
+async function applyContextBudgetIfNeeded(params) {
+    const budget = params.contextBudget;
+    if (!budget || budget.contextWindowTokens <= 0) {
+        return { contextPackage: params.contextPackage, notes: [] };
+    }
+    const availableInputTokens = budget.contextWindowTokens - Math.max(0, budget.reservedOutputTokens);
+    const selectedContext = params.contextPackage.selectedContext;
+    const totalTokens = estimateSelectedContextTokens(selectedContext);
+    if (totalTokens <= availableInputTokens) {
+        return { contextPackage: params.contextPackage, notes: [] };
+    }
+    const protectedEntries = selectedContext.filter((entry) => isProtectedContextSource(entry.source));
+    const compressibleEntries = selectedContext.filter((entry) => !isProtectedContextSource(entry.source));
+    const protectedTokens = estimateSelectedContextTokens(protectedEntries);
+    if (protectedTokens > availableInputTokens) {
+        params.onContextCompression?.({
+            category: "story_context",
+            phase: "error",
+            message: "Protected context exceeds available input budget.",
+            protectedTokens,
+            compressibleTokens: totalTokens - protectedTokens,
+            budgetTokens: availableInputTokens,
+            sources: protectedEntries.map((entry) => entry.source),
+        });
+        throw new Error(`Protected context exceeds available input budget (${protectedTokens}/${availableInputTokens} tokens). ` +
+            "InkOS will not compress protected author intent, current focus, hard state, or active hook evidence.");
+    }
+    if (compressibleEntries.length === 0) {
+        return { contextPackage: params.contextPackage, notes: ["context-over-budget-no-compressible-entries"] };
+    }
+    if (!params.compiler) {
+        params.onContextCompression?.({
+            category: "story_context",
+            phase: "error",
+            message: "Context exceeds available input budget but no compiler was provided.",
+            protectedTokens,
+            compressibleTokens: estimateSelectedContextTokens(compressibleEntries),
+            budgetTokens: availableInputTokens,
+            sources: compressibleEntries.map((entry) => entry.source),
+        });
+        throw new Error(`Context exceeds available input budget (${totalTokens}/${availableInputTokens} tokens), ` +
+            "but no compressible context compiler was provided.");
+    }
+    const compileBudget = Math.max(1, availableInputTokens - protectedTokens);
+    const compressibleTokens = estimateSelectedContextTokens(compressibleEntries);
+    params.onContextCompression?.({
+        category: "story_context",
+        phase: "start",
+        protectedTokens,
+        compressibleTokens,
+        budgetTokens: compileBudget,
+        sources: compressibleEntries.map((entry) => entry.source),
+    });
+    let compiled;
+    try {
+        compiled = (await params.compiler({
+            chapterNumber: params.chapterNumber,
+            goal: params.goal,
+            language: params.language,
+            maxInputTokens: compileBudget,
+            protectedEntries,
+            compressibleEntries,
+        })).trim();
+    }
+    catch (error) {
+        params.onContextCompression?.({
+            category: "story_context",
+            phase: "error",
+            message: error instanceof Error ? error.message : String(error),
+            protectedTokens,
+            compressibleTokens,
+            budgetTokens: compileBudget,
+            sources: compressibleEntries.map((entry) => entry.source),
+        });
+        throw error;
+    }
+    if (!compiled) {
+        params.onContextCompression?.({
+            category: "story_context",
+            phase: "error",
+            message: "Compressible context compiler returned empty output.",
+            protectedTokens,
+            compressibleTokens,
+            budgetTokens: compileBudget,
+            sources: compressibleEntries.map((entry) => entry.source),
+        });
+        throw new Error("Compressible context compiler returned empty output.");
+    }
+    params.onContextCompression?.({
+        category: "story_context",
+        phase: "end",
+        protectedTokens,
+        compressibleTokens,
+        budgetTokens: compileBudget,
+        sources: compressibleEntries.map((entry) => entry.source),
+    });
+    return {
+        contextPackage: ContextPackageSchema.parse({
+            chapter: params.contextPackage.chapter,
+            selectedContext: [
+                ...protectedEntries,
+                {
+                    source: "runtime/compiled-compressible-context",
+                    reason: "Semantic compilation of lower-priority context after protected context exceeded the input budget.",
+                    excerpt: compiled,
+                },
+            ],
+        }),
+        notes: ["compiled-compressible-context"],
+    };
+}
+function estimateSelectedContextTokens(entries) {
+    return entries.reduce((total, entry) => (total + estimateTextTokens([entry.source, entry.reason, entry.excerpt].filter(Boolean).join("\n"))), 0);
+}
+function renderContextEntries(entries) {
+    return entries.map((entry) => [
+        `### ${entry.source}`,
+        `Reason: ${entry.reason}`,
+        entry.excerpt ? entry.excerpt : "(no excerpt)",
+    ].join("\n")).join("\n\n");
+}
+function parseSelectedSources(raw) {
+    const trimmed = raw.trim()
+        .replace(/^```(?:json)?\s*/i, "")
+        .replace(/```\s*$/i, "")
+        .trim();
+    const parse = (value) => JSON.parse(value);
+    let parsed;
+    try {
+        parsed = parse(trimmed);
+    }
+    catch {
+        const start = trimmed.indexOf("{");
+        const end = trimmed.lastIndexOf("}");
+        if (start < 0 || end <= start)
+            return [];
+        try {
+            parsed = parse(trimmed.slice(start, end + 1));
+        }
+        catch {
+            return [];
+        }
+    }
+    if (!parsed || typeof parsed !== "object")
+        return [];
+    const values = parsed.selectedSources;
+    if (!Array.isArray(values))
+        return [];
+    return values.filter((value) => typeof value === "string" && value.trim().length > 0);
+}
 export class ComposerAgent extends BaseAgent {
     get name() {
         return "composer";
     }
     async composeChapter(input) {
-        return composeGovernedChapter(input);
+        const contextBudget = input.contextBudget ?? contextBudgetFromClient(this.ctx.client);
+        return composeGovernedChapter({
+            ...input,
+            contextBudget,
+            compressibleContextCompiler: input.compressibleContextCompiler
+                ?? (contextBudget ? (request) => this.compileCompressibleContext(request) : undefined),
+            outlineSectionSelector: input.outlineSectionSelector ?? ((request) => this.selectOutlineSections(request)),
+        });
+    }
+    async selectOutlineSections(request) {
+        if (request.candidates.length <= 1) {
+            return request.candidates.map((candidate) => candidate.source);
+        }
+        const isEn = request.language === "en";
+        const candidates = request.candidates.map((candidate, index) => [
+            `#${index + 1} ${candidate.source}`,
+            `heading: ${candidate.heading}`,
+            candidate.excerpt,
+        ].join("\n")).join("\n\n");
+        const system = isEn
+            ? [
+                "You are InkOS's semantic outline-section selector.",
+                "Select only the outline sections needed for the current chapter. Prefer semantic relevance over keyword overlap.",
+                "Return strict JSON only: {\"selectedSources\":[\"...\"]}. Use exact source ids from the candidates. If uncertain, include the safest relevant anchors rather than inventing ids.",
+            ].join("\n")
+            : [
+                "你是 InkOS 的语义大纲选段器。",
+                "只选择当前章节真正需要的大纲段落。按语义相关性判断，不要按关键词重合机械选择。",
+                "只返回严格 JSON：{\"selectedSources\":[\"...\"]}。必须使用候选里的精确 source id；不确定时选最安全的相关锚点，不要编造 id。",
+            ].join("\n");
+        const user = isEn
+            ? [
+                `File: ${request.fileName}`,
+                `Chapter: ${request.chapterNumber}`,
+                `Goal: ${request.goal}`,
+                `Outline node: ${request.outlineNode}`,
+                "",
+                "Candidates:",
+                candidates,
+            ].join("\n")
+            : [
+                `文件：${request.fileName}`,
+                `章节：第${request.chapterNumber}章`,
+                `目标：${request.goal}`,
+                `大纲节点：${request.outlineNode}`,
+                "",
+                "候选段落：",
+                candidates,
+            ].join("\n");
+        const response = await this.chat([
+            { role: "system", content: system },
+            { role: "user", content: user },
+        ], {
+            temperature: 0.1,
+            maxTokens: 1024,
+        });
+        const allowed = new Set(request.candidates.map((candidate) => candidate.source));
+        return parseSelectedSources(response.content).filter((source) => allowed.has(source));
     }
+    async compileCompressibleContext(request) {
+        const isEn = request.language === "en";
+        const protectedBlock = renderContextEntries(request.protectedEntries);
+        const compressibleBlock = renderContextEntries(request.compressibleEntries);
+        const system = isEn
+            ? [
+                "You are InkOS's semantic context compiler.",
+                "Only compile the COMPRESSIBLE CONTEXT. The PROTECTED CONTEXT is binding reference material and must not be rewritten, summarized as a substitute, or weakened.",
+                "Output concise Markdown with source pointers. Preserve names, unresolved promises, evidence, timing, and constraints that may affect the next chapter. Drop low-relevance noise.",
+            ].join("\n")
+            : [
+                "你是 InkOS 的语义上下文编译器。",
+                "只能编译【可压缩上下文】。【受保护上下文】是绑定参照，不得改写、不得替代总结、不得削弱。",
+                "输出简洁 Markdown，保留来源指针。保留会影响下一章的人名、未兑现承诺、证据、时间点和约束，丢弃低相关噪声。",
+            ].join("\n");
+        const user = isEn
+            ? [
+                `Chapter: ${request.chapterNumber}`,
+                `Goal: ${request.goal}`,
+                `Target budget for compiled context: <= ${request.maxInputTokens} estimated input tokens`,
+                "",
+                "## Protected Context (reference only, do not compile)",
+                protectedBlock || "(none)",
+                "",
+                "## Compressible Context (compile this)",
+                compressibleBlock || "(none)",
+            ].join("\n")
+            : [
+                `章节：第${request.chapterNumber}章`,
+                `目标：${request.goal}`,
+                `压缩后目标预算：不超过 ${request.maxInputTokens} 估算输入 tokens`,
+                "",
+                "## 受保护上下文（只作为参照，不要编译它）",
+                protectedBlock || "（无）",
+                "",
+                "## 可压缩上下文（只编译这一部分）",
+                compressibleBlock || "（无）",
+            ].join("\n");
+        const response = await this.chat([
+            { role: "system", content: system },
+            { role: "user", content: user },
+        ], {
+            temperature: 0.2,
+            maxTokens: Math.min(8192, Math.max(512, request.maxInputTokens)),
+        });
+        return response.content.trim();
+    }
+}
+export function contextBudgetFromClient(client) {
+    const contextWindowTokens = client._piModel?.contextWindow;
+    if (!Number.isFinite(contextWindowTokens) || !contextWindowTokens || contextWindowTokens <= 0) {
+        return undefined;
+    }
+    return {
+        contextWindowTokens,
+        reservedOutputTokens: Math.max(0, client.defaults.maxTokens),
+    };
 }
-async function collectSelectedContext(storyDir, plan, language) {
+async function collectSelectedContext(storyDir, plan, language, outlineSectionSelector) {
     const retrievalHints = deriveRetrievalHints(plan);
     const memoBodyExcerpt = plan.memo.body.trim();
     const chapterMemoEntry = memoBodyExcerpt.length > 0
@@ -65,10 +341,15 @@ async function collectSelectedContext(storyDir, plan, language) {
             }];
     const entries = await Promise.all([
         maybeContextSource(storyDir, "current_focus.md", "Current task focus for this chapter."),
+        maybeContextSource(storyDir, "author_intent.md", "User's long-term authorial intent and direction — binding, overrides model defaults."),
         maybeContextSource(storyDir, "audit_drift.md", "Carry forward audit drift guidance from the previous chapter without polluting hard state facts."),
-        maybeContextSource(storyDir, "current_state.md", "Preserve hard state facts referenced by the active chapter brief or hard constraints.", retrievalHints),
-        maybeContextSource(storyDir, "outline/story_frame.md", "Preserve canon constraints referenced by the active chapter brief or hard constraints.", retrievalHints),
-        maybeContextSource(storyDir, "outline/volume_map.md", "Anchor the default planning node for this chapter.", plan.intent.outlineNode ? [plan.intent.outlineNode] : []),
+        maybeContextSource(storyDir, "current_state.md", "Preserve hard state facts referenced by the active chapter brief or hard constraints."),
+    ]);
+    const outlineEntries = [
+        ...await maybeOutlineSectionSources(storyDir, "outline/story_frame.md", "Preserve canon constraints referenced by the active chapter brief or hard constraints.", plan, "story-frame", language, outlineSectionSelector),
+        ...await maybeOutlineSectionSources(storyDir, "outline/volume_map.md", "Anchor the default planning node for this chapter.", plan, "volume-map", language, outlineSectionSelector),
+    ];
+    const canonEntries = await Promise.all([
         maybeContextSource(storyDir, "parent_canon.md", "Preserve parent canon constraints for governed continuation or fanfic writing."),
         maybeContextSource(storyDir, "fanfic_canon.md", "Preserve extracted fanfic canon constraints for governed writing."),
     ]);
@@ -108,6 +389,8 @@ async function collectSelectedContext(storyDir, plan, language) {
     return [
         ...chapterMemoEntry,
         ...entries.filter((entry) => entry !== null),
+        ...outlineEntries,
+        ...canonEntries.filter((entry) => entry !== null),
         ...trailEntries,
         ...hookDebtEntries,
         ...factEntries,
@@ -242,7 +525,7 @@ async function buildHookDebtEntries(storyDir, plan, activeHooks, language) {
             }];
     });
 }
-async function maybeContextSource(storyDir, fileName, reason, preferredExcerpts = []) {
+async function maybeContextSource(storyDir, fileName, reason) {
     const path = join(storyDir, fileName);
     let content = await readFileOrDefault(path);
     let resolvedFileName = fileName;
@@ -264,9 +547,219 @@ async function maybeContextSource(storyDir, fileName, reason, preferredExcerpts
     return {
         source: `story/${resolvedFileName}`,
         reason,
-        excerpt: pickExcerpt(content, preferredExcerpts),
+        excerpt: content.trim(),
     };
 }
+async function maybeOutlineSectionSources(storyDir, fileName, reason, plan, kind, language, outlineSectionSelector) {
+    const path = join(storyDir, fileName);
+    const content = await readFileOrDefault(path);
+    if (!content || content === "(文件尚未创建)") {
+        const legacyFallback = outlineFallback(fileName);
+        if (!legacyFallback)
+            return [];
+        const legacyContent = await readFileOrDefault(join(storyDir, legacyFallback));
+        if (!legacyContent || legacyContent === "(文件尚未创建)")
+            return [];
+        return await selectOutlineSectionEntries({
+            fileName: legacyFallback,
+            content: legacyContent,
+            reason,
+            plan,
+            kind,
+            language,
+            outlineSectionSelector,
+        });
+    }
+    return await selectOutlineSectionEntries({
+        fileName,
+        content,
+        reason,
+        plan,
+        kind,
+        language,
+        outlineSectionSelector,
+    });
+}
+async function selectOutlineSectionEntries(params) {
+    const sections = splitMarkdownSections(params.content);
+    if (sections.length === 0) {
+        return [{
+                source: `story/${params.fileName}#document`,
+                reason: params.reason,
+                excerpt: params.content.trim(),
+            }];
+    }
+    const hints = deriveOutlineSelectionHints(params.plan);
+    const selected = sections.filter((section) => params.kind === "story-frame"
+        ? isRelevantStoryFrameSection(section, hints)
+        : isRelevantVolumeMapSection(section, hints, params.plan.intent.chapter));
+    const finalSections = selected.length > 0 ? selected : fallbackOutlineSections(sections, params.kind, params.plan.intent.chapter);
+    const candidates = sections.map((section) => ({
+        source: `story/${params.fileName}#${slugifyAnchor(section.heading)}`,
+        heading: section.heading,
+        excerpt: section.raw.trim(),
+    }));
+    if (params.outlineSectionSelector) {
+        try {
+            const selectedSources = await params.outlineSectionSelector({
+                fileName: params.fileName,
+                kind: params.kind,
+                chapterNumber: params.plan.intent.chapter,
+                goal: params.plan.intent.goal,
+                outlineNode: params.plan.intent.outlineNode ?? "",
+                language: params.language,
+                candidates,
+            });
+            const selectedSourceSet = new Set(selectedSources);
+            const llmSections = sections.filter((section) => selectedSourceSet.has(`story/${params.fileName}#${slugifyAnchor(section.heading)}`));
+            if (llmSections.length > 0) {
+                return dedupeBySource(llmSections.map((section) => ({
+                    source: `story/${params.fileName}#${slugifyAnchor(section.heading)}`,
+                    reason: params.reason,
+                    excerpt: section.raw.trim(),
+                })));
+            }
+        }
+        catch {
+            // Semantic section selection is quality guidance, not a hard dependency.
+            // If the provider flakes or returns malformed JSON, keep the deterministic
+            // fallback so chapter production does not stall.
+        }
+    }
+    return dedupeBySource(finalSections.map((section) => ({
+        source: `story/${params.fileName}#${slugifyAnchor(section.heading)}`,
+        reason: params.reason,
+        excerpt: section.raw.trim(),
+    })));
+}
+function splitMarkdownSections(content) {
+    const sections = [];
+    let current = null;
+    for (const line of content.split(/\r?\n/)) {
+        const headingMatch = /^(#{1,6})\s+(.+?)\s*$/.exec(line);
+        if (headingMatch) {
+            if (current && current.lines.some((entry) => entry.trim().length > 0)) {
+                sections.push(current);
+            }
+            current = {
+                heading: headingMatch[2].trim(),
+                lines: [line],
+            };
+            continue;
+        }
+        if (current) {
+            current.lines.push(line);
+        }
+    }
+    if (current && current.lines.some((entry) => entry.trim().length > 0)) {
+        sections.push(current);
+    }
+    return sections
+        .map((section) => ({
+        heading: section.heading,
+        raw: section.lines.join("\n").trim(),
+    }))
+        .filter((section) => section.raw.length > 0);
+}
+function deriveOutlineSelectionHints(plan) {
+    return [
+        plan.intent.goal,
+        plan.intent.outlineNode,
+        plan.intent.arcContext,
+        ...plan.intent.mustKeep,
+        ...plan.intent.mustAvoid,
+        ...plan.intent.styleEmphasis,
+        plan.memo.goal,
+        plan.memo.body,
+        ...plan.memo.threadRefs,
+    ].filter((value) => Boolean(value && value.trim()));
+}
+function isRelevantStoryFrameSection(section, hints) {
+    const heading = normalizeForMatch(section.heading);
+    const sectionText = normalizeForMatch(section.raw);
+    const hardHeadingSignals = [
+        "世界观",
+        "底色",
+        "铁律",
+        "规则",
+        "核心冲突",
+        "终局",
+        "world",
+        "tonal",
+        "rule",
+        "core conflict",
+        "endgame",
+    ];
+    if (hardHeadingSignals.some((signal) => heading.includes(normalizeForMatch(signal)))) {
+        return true;
+    }
+    return matchesOutlineHints(sectionText, hints);
+}
+function isRelevantVolumeMapSection(section, hints, chapterNumber) {
+    const heading = normalizeForMatch(section.heading);
+    if (headingMentionsChapter(heading, chapterNumber)) {
+        return true;
+    }
+    return matchesOutlineHints(normalizeForMatch(section.raw), hints);
+}
+function matchesOutlineHints(sectionText, hints) {
+    for (const hint of hints) {
+        const terms = extractMatchTerms(hint);
+        if (terms.length === 0)
+            continue;
+        const hits = terms.filter((term) => sectionText.includes(term));
+        if (hits.length >= Math.min(2, terms.length)) {
+            return true;
+        }
+    }
+    return false;
+}
+function fallbackOutlineSections(sections, kind, chapterNumber) {
+    if (kind === "volume-map") {
+        const chapterHit = sections.find((section) => headingMentionsChapter(normalizeForMatch(section.heading), chapterNumber));
+        if (chapterHit)
+            return [chapterHit];
+    }
+    return sections.slice(0, 1);
+}
+function extractMatchTerms(value) {
+    const normalized = normalizeForMatch(value);
+    const terms = new Set();
+    for (const term of normalized.match(/[a-z0-9]{3,}/g) ?? []) {
+        terms.add(term);
+    }
+    for (const term of normalized.match(/[\u4e00-\u9fff]{2,}/g) ?? []) {
+        terms.add(term);
+    }
+    return [...terms].filter((term) => term.length >= 2);
+}
+function normalizeForMatch(value) {
+    return value.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function headingMentionsChapter(normalizedHeading, chapterNumber) {
+    return normalizedHeading.includes(`chapter ${chapterNumber}`)
+        || normalizedHeading.includes(`chapter${chapterNumber}`)
+        || normalizedHeading.includes(`ch.${chapterNumber}`)
+        || normalizedHeading.includes(`ch${chapterNumber}`)
+        || normalizedHeading.includes(`第${chapterNumber}章`);
+}
+function slugifyAnchor(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9\u4e00-\u9fff]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        || "section";
+}
+function dedupeBySource(entries) {
+    const seen = new Set();
+    return entries.filter((entry) => {
+        if (seen.has(entry.source))
+            return false;
+        seen.add(entry.source);
+        return true;
+    });
+}
 function outlineFallback(fileName) {
     if (fileName === "outline/story_frame.md")
         return "story_bible.md";
@@ -274,16 +767,6 @@ function outlineFallback(fileName) {
         return "volume_outline.md";
     return null;
 }
-function pickExcerpt(content, preferredExcerpts) {
-    for (const preferred of preferredExcerpts) {
-        if (preferred && content.includes(preferred))
-            return preferred;
-    }
-    return content
-        .split("\n")
-        .map((line) => line.trim())
-        .find((line) => line.length > 0 && !line.startsWith("#"));
-}
 function toFactAnchor(predicate) {
     return predicate
         .trim()