@oh-story/dsh 0.1.9 → 0.1.11

package/lib/oh-story/skills/story-long-write/scripts/build_architect_brief.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+"""build_architect_brief.py — 把「出卷纲」「出一批细纲」这一时刻要用的流程与模板拼成任务包。
+
+用法:
+    python build_architect_brief.py --project <书目录> --task world
+    python build_architect_brief.py --project <书目录> --task volume [--volume N]
+    python build_architect_brief.py --project <书目录> --task outline --chapters A-B
+    python build_architect_brief.py --project <临时目录> --task <任务> --rules-only   # 仓库预算守卫计量用
+
+开书与规划按作者确认点分时刻（见 references/workflow-setup.md）。卷纲与每批细纲最重，
+有子代理时交给 story-architect 在新上下文里做：主会话只跑本脚本、把任务包路径交给它，
+自己不读包里的内容。任务包写在书内 `.story/work/排纲/`，是这次任务的输入数据，不是 reference。
+
+包里只有该时刻需要的东西，三种任务都附 SKILL.md 的「新增物三级」判据（包外读不到 SKILL.md）：
+- world：workflow-setup.md 的 Phase 2 与设定模板、character-basics.md、long-genre-mechanics.md 的
+  「核心梗三层递进设计」、character-relations.md 的「人物关系类型」、reader-contract-and-progression.md。
+- volume：workflow-volume.md（卷纲流程、排纲自查、节奏锚与对标迁移）、artifact-protocols.md
+  （大纲与卷纲模板）、emotional-methods.md 的「长篇单元情绪引擎」（排纲自查第 1 项）、
+  reader-contract-and-progression.md（第 4 项契约四问）。
+- outline：workflow-outline.md（批次步骤、细纲模板与验收、补纲、设定补全、排纲底稿模板）、
+  character-basics.md 的主角卡与配角卡模板；首章在范围内时加 opening-design.md。
+流程里点名、但只在某些书才用得上的参考（多对标时的跨书召回、女频手册、弧线与反转速查、灵感库）
+不进包，列在包末「按条件可读」，给出绝对路径与小节，条件满足才读。
+本书的方向、设定与作者口头定下的事都在 `设定/`，不进包，由执行者按包里的流程定点读。
+`--rules-only` 只拼规则部分（不取本书卷纲），供仓库的预算守卫计量每次调用的加载量。
+
+stdout 输出一行 JSON：任务包路径、字数（去空白）、包含的资料。
+Exit: 0 = 已写出；2 = 参数或资料缺失（含卷纲单元只覆盖了请求章节的一部分）。
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from outline_view import parse as parse_volume, slice_arc, strip_retired, unit_chapter_range  # noqa: E402
+
+SKILL_ROOT = Path(__file__).resolve().parent.parent
+REFERENCES = SKILL_ROOT / "references"
+WORK_DIR = (".story", "work", "排纲")
+# 包外按条件可读：(文件, 小节或 None=整份, 条件)。条件由执行者读 `设定/` 判断。
+CROSS_BOOK = ("cross-book-recall.md", None, "`设定/题材定位.md`「对标登记」里有 2 本及以上对标书")
+INSPIRATION = ("cross-book-recall.md", "公共灵感标签召回", "工作区有 `灵感库/`（零命中不阻塞）")
+CONDITIONAL = {
+    "world": [("female-audience-writing.md", None, "本书是女频"), CROSS_BOOK, INSPIRATION],
+    "volume": [CROSS_BOOK, ("emotional-arc-design.md", "六种弧线速查", "情绪弧线选型拿不准"),
+               ("long-reversal.md", "反转类型", "本卷规划了反转"), INSPIRATION],
+    "outline": [CROSS_BOOK, INSPIRATION],
+}
+
+
+def read_reference(name: str) -> str:
+    path = REFERENCES / name
+    if not path.is_file():
+        raise SystemExit(f"ERROR: 缺少 reference：{path}")
+    return path.read_text(encoding="utf-8").lstrip("")
+
+
+def section(text: str, start: str, end: str | None = None) -> str:
+    """取 start 标题行到 end 标题行之前（end 省略则到文末）；找不到 start 就报错，不静默给空。"""
+    match = re.search(rf"^#+\s*{re.escape(start)}.*$", text, re.M)
+    if match is None:
+        raise SystemExit(f"ERROR: reference 里找不到小节「{start}」")
+    stop = re.search(rf"^#+\s*{re.escape(end)}.*$", text[match.end():], re.M) if end else None
+    return text[match.start(): match.end() + stop.start() if stop else len(text)].rstrip()
+
+
+def new_addition_tiers() -> str:
+    """SKILL.md 的「新增物三级」判据：排纲、定设定都要按它分级，而任务包外的 SKILL.md 读不到。"""
+    text = (SKILL_ROOT / "SKILL.md").read_text(encoding="utf-8")
+    match = re.search(r"^> \*\*新增物三级\*\*.*?(?=^(?!>))", text, re.M | re.S)
+    if match is None:
+        raise SystemExit("ERROR: SKILL.md 里找不到「新增物三级」")
+    return "\n".join(line[2:] if line.startswith("> ") else line.lstrip(">") for line in match.group(0).rstrip().splitlines())
+
+
+def conditional_reads(task: str) -> str:
+    lines = ["下面几份在包外，只在条件满足时读，只读点名的那一节（没点名读整份）；条件不满足不读："]
+    for name, part, when in CONDITIONAL[task]:
+        where = f"「{part}」一节" if part else "整份"
+        lines.append(f"- {when}：读 `{REFERENCES / name}` {where}")
+    return "\n".join(lines)
+
+
+def emit(text: str, stream) -> None:
+    """统一按 UTF-8 写出：Windows 控制台默认 GBK/ASCII 时直接 print 中文会崩。"""
+    stream.buffer.write((text + "\n").encode("utf-8"))
+    stream.flush()
+
+
+def render(sections, chosen, span, preamble) -> str:
+    """与 outline_view.emit 同一取法（剔除已退役条目、情绪弧线按单元截段），只是返回文本。"""
+    out = ["\n".join(strip_retired(preamble, False)).rstrip()] if preamble else []
+    for sec in sections:
+        if sec not in chosen:
+            continue
+        body = slice_arc(sec, span) if ("情绪弧线" in sec.title or "排班" in sec.title) else sec.lines
+        out.append("\n".join(strip_retired(body, False)).rstrip())
+    return "\n\n".join(out) + "\n"
+
+
+def unit_closures(project: Path, first: int, last: int) -> list[tuple[str, str]]:
+    """story-architect 没有执行命令的权限：由脚本先把覆盖本批章节的剧情单元闭包取出来放进包里。
+
+    取法同 `outline_view.py --unit U --stage outline`；一卷里有几个单元时，卷契约与卷级常任只随第一个单元给一次。"""
+    found: list[tuple[str, str]] = []
+    covered: set[int] = set()
+    undeclared: list[str] = []
+    for volume in sorted((project / "大纲").glob("卷纲_第*卷.md")):
+        lines, sections = parse_volume(volume.read_text(encoding="utf-8"))
+        # 单元卡有标题、没写作用域行时取段器认不出它——点名缺哪一行，而不是笼统说找不到单元。
+        undeclared += [f"{volume.name}「{s.title.strip()}」" for s in sections
+                       if s.scope is None and s.unit and "剧情单元" in s.title]
+        if any(s.scope and (s.kind is None or (s.kind != "卷级常任" and s.unit is None)) for s in sections):
+            raise SystemExit(f"ERROR: {volume.name} 作用域声明无效，先跑 outline_view.py --check 修正")
+        active = [s for s in sections if s.status != "已退役"]
+        shared = [s for s in active if s.kind == "卷级常任" or s.scope is None]
+        units = sorted({s.unit for s in active if s.unit and s.kind == "单元级"})
+        given = False
+        for unit in units:
+            span = unit_chapter_range(active, unit)
+            if not (span and span[0] <= last and span[1] >= first):
+                continue
+            covered.update(range(span[0], span[1] + 1))
+            live = [s for s in active if s.unit == unit and s.kind in ("单元级", "批次底稿")]
+            if given:
+                text = "（卷契约与卷级常任同上一段，不重复。）\n\n" + render(sections, set(live), span, None)
+            else:
+                text = render(sections, set(shared + live), span, lines[:sections[0].start] if sections else None)
+            given = True
+            found.append((f"{volume.name} · 单元 {unit}（第{span[0]}-{span[1]}章）", text))
+    missing = [n for n in range(first, last + 1) if n not in covered]
+    if missing:
+        hint = (f"；这些单元卡缺「> 作用域：单元级 {{单元ID}}」声明行：{'、'.join(undeclared)}"
+                if undeclared else "（单元卡要写「> 作用域：单元级 {单元ID}」和「章节范围：第A-B章」）")
+        where = "找不到覆盖" if not found else "剧情单元只覆盖了一部分，缺覆盖"
+        raise SystemExit(f"ERROR: 卷纲里{where}第{compress(missing)}章的剧情单元{hint}，先补卷纲"
+                         "（`outline_view.py --check --strict` 列出全部问题）")
+    return found
+
+
+def compress(numbers: list[int]) -> str:
+    """[4, 5, 6, 9] → 4-6、9"""
+    spans, start = [], numbers[0]
+    for prev, cur in zip(numbers, numbers[1:] + [None]):
+        if cur != prev + 1:
+            spans.append(f"{start}-{prev}" if start != prev else f"{start}")
+            start = cur
+    return "、".join(spans)
+
+
+def weight(text: str) -> int:
+    return len(re.sub(r"\s", "", text))
+
+
+def build(task: str, volume: int | None, chapters: tuple[int, int] | None,
+          project: Path | None = None, rules_only: bool = False) -> tuple[str, list[str]]:
+    outside = "写作技法只读本包，外加包末「按条件可读」里条件满足的那几节。"
+    if task == "world":
+        head = ("# 任务包：出核心设定提案\n\n"
+                "按下面 Phase 2 的流程，把核心设定写成文件：`设定/题材定位.md`（在定方向时已写的部分上补全，不删作者已定的内容）、"
+                "`设定/关系.md`、主角与关键角色的 `设定/角色/{名}.md`、影响全书的 `设定/世界观/{主题}.md`。"
+                "作者在定方向时说过的话都在 `设定/题材定位.md`，先读它；拿不准的写成二选一的候选留给作者定，不替作者拍板，"
+                "物价、收入、力量档位这类全书刻度按下附「新增物三级」属先问作者，只给候选。"
+                f"不出卷纲、不写正文。{outside}交付后只回：写了哪些文件、主角与核心冲突各一句、"
+                "要作者定的事（没有写「无」）。")
+        setup = read_reference("workflow-setup.md")
+        parts = [("workflow-setup.md（Phase 2 与设定模板）",
+                  section(setup, "Phase 2：核心设定", "Agent 调用：story-architect + character-designer") + "\n\n"
+                  + section(setup, "定设定时建的文件模板")),
+                 ("character-basics.md", read_reference("character-basics.md")),
+                 ("long-genre-mechanics.md（核心梗三层递进设计）",
+                  section(read_reference("long-genre-mechanics.md"), "核心梗三层递进设计", "微创新与差异化设计")),
+                 ("character-relations.md（人物关系类型）",
+                  section(read_reference("character-relations.md"), "人物关系类型", "感情流人设核心法")),
+                 ("reader-contract-and-progression.md", read_reference("reader-contract-and-progression.md"))]
+    elif task == "volume":
+        label = f"第{volume}卷" if volume else "本卷"
+        head = (f"# 任务包：出{label}卷纲\n\n"
+                f"只交付全书体量与阶段总览（`大纲/大纲.md`，已有就只补本卷相关部分）和 `大纲/卷纲_第{volume or 'X'}卷.md`，"
+                "不出细纲、不写正文、不建 `追踪/`。本书方向、设定、对标登记与作者已定的事读 `设定/`（先读 "
+                f"`设定/题材定位.md`）。{outside}交付后只回：写了哪些文件、排纲自查 1–4 "
+                "的结论各一句、要作者定的事（没有写「无」）。")
+        parts = [("workflow-volume.md", read_reference("workflow-volume.md")),
+                 ("artifact-protocols.md", read_reference("artifact-protocols.md")),
+                 ("emotional-methods.md（长篇单元情绪引擎）",
+                  section(read_reference("emotional-methods.md"), "长篇单元情绪引擎", "决策路由")),
+                 ("reader-contract-and-progression.md", read_reference("reader-contract-and-progression.md"))]
+    else:
+        first, last = chapters
+        head = (f"# 任务包：出第{first}-{last}章细纲\n\n"
+                f"只交付 `大纲/细纲_第{first:03d}章` 到第{last:03d}章，以及排纲底稿与必要的设定补全，不写正文、"
+                "不建 `追踪/`。本批涉及的卷纲单元段附在包末（已按单元取好），卷纲本身不整读；设定从 `设定/` 定点读；"
+                f"{outside}交付后只回：写了哪些文件、"
+                "每章一句核心事件、要作者定的事（没有写「无」）。")
+        basics = read_reference("character-basics.md")
+        parts = [("workflow-outline.md", read_reference("workflow-outline.md")),
+                 ("character-basics.md（主角卡、配角卡）", section(basics, "第1节：主角卡", "第3节"))]
+        if first <= 3:
+            parts.append(("opening-design.md", read_reference("opening-design.md")))
+        if not rules_only:
+            parts += [(f"卷纲取段：{name}", text) for name, text in unit_closures(project, first, last)]
+    parts.append(("SKILL.md（新增物三级）", new_addition_tiers()))
+    parts.append(("按条件可读（包外）", conditional_reads(task)))
+    body = [head + ("\n\n包里流程写到的脚本命令（取段、`--check`、`check-outline-contract.js`）由主会话在你交付后跑，"
+                    "你不执行命令；需要的取段结果已放进包里。")]
+    for name, text in parts:
+        body.append(f"\n---\n\n<!-- 资料：{name} -->\n\n{text.strip()}\n")
+    return "\n".join(body), [name for name, _ in parts]
+
+
+def parse_range(value: str) -> tuple[int, int]:
+    match = re.fullmatch(r"\s*(\d+)\s*(?:-\s*(\d+))?\s*", value or "")
+    if not match:
+        raise SystemExit("ERROR: --chapters 写成 A-B，如 1-10")
+    first = int(match.group(1))
+    last = int(match.group(2) or first)
+    if first < 1 or last < first:
+        raise SystemExit("ERROR: --chapters 范围无效")
+    return first, last
+
+
+def main(argv=None) -> int:
+    parser = argparse.ArgumentParser(description="拼出 story-architect 出卷纲/细纲的任务包")
+    parser.add_argument("--project", required=True, type=Path, help="书目录")
+    parser.add_argument("--task", required=True, choices=("world", "volume", "outline"))
+    parser.add_argument("--volume", type=int, help="卷号（volume 任务）")
+    parser.add_argument("--chapters", help="章节范围 A-B（outline 任务）")
+    parser.add_argument("--rules-only", action="store_true", help="只拼规则部分、不取本书卷纲（预算守卫计量用）")
+    args = parser.parse_args(argv)
+    try:
+        if not args.project.is_dir():
+            raise SystemExit(f"ERROR: 书目录不存在：{args.project}")
+        chapters = parse_range(args.chapters) if args.task == "outline" else None
+        if args.task == "outline" and chapters[1] - chapters[0] >= 10:
+            raise SystemExit("ERROR: 一批细纲最多 10 章，拆成两批")
+        text, included = build(args.task, args.volume, chapters, args.project, args.rules_only)
+    except SystemExit as exc:
+        emit(str(exc), sys.stderr)
+        return 2
+    out_dir = args.project.joinpath(*WORK_DIR)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    if args.task == "world":
+        name = "核心设定.md"
+    elif args.task == "volume":
+        name = f"卷纲_第{args.volume}卷.md" if args.volume else "卷纲.md"
+    else:
+        name = f"细纲_第{chapters[0]:03d}-{chapters[1]:03d}章.md"
+    out = out_dir / name
+    out.write_text(text, encoding="utf-8")
+    emit(json.dumps({"brief": str(out), "chars": weight(text), "includes": included}, ensure_ascii=False), sys.stdout)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/lib/oh-story/skills/story-long-write/scripts/build_writer_prompt.py

@@ -2,7 +2,12 @@
 """build_writer_prompt.py — 确定性组装 narrative-writer 的 spawn prompt 骨架。
 
 用法:
-    python build_writer_prompt.py --project <书目录> --chapter N [--out <文件>]
+    python build_writer_prompt.py --project <书目录> --chapter N [--out [<文件>]]
+
+`--out` 不带路径时留档到本章工作目录 `<书目录>/.story/work/第NNN章/writer_prompt.md`。
+分组 segment、prompt 留档和逐章事务 JSON 都只放这个书内工作目录——不写系统 /tmp
+（多本书/多会话同章号会互相覆盖，Windows 也没有 /tmp），也不写进 正文/（会被当成章节）。
+`storyctl.py chapter commit` 成功后自动删除该章工作目录。
 
 跑在「写前准备」第一步。stdout 分两区，`===` 分隔线以上是 prompt 正文
 （主会话照抄，空槽以外一字不改），以下是核对报告（不进 prompt）。
@@ -10,10 +15,16 @@
 职责边界:
 - 脚本做确定性部分：固定首行、定位、标题行字面量、细纲指针、文风全文路径与裁决、
   上一章结尾、降档判定与情绪/节奏槽、固定块指针。
-- 主会话填八槽：执行安排 / 本章意图 / 参考技法 / 本节速记 / 涉及角色 / genre_prose_card /
-  必读设定 / author_preferences。降档不成立时情绪与节奏槽也归主会话。
-  材料槽对应原流程步骤 3「写前准备」的四项输出（本节速记 / 情绪目标 / 涉及角色 /
-  参考技法）加上题材卡、设定补漏与作者偏好——都是判断，脚本做不了。
+- 脚本代查作者记忆（prose_style + story_design）并填好 author_preferences。
+- 脚本注入 `设定/题材定位.md`「作者已定」（本书的偏好、红线与否掉的方案），超过 AUTHOR_DECIDED_CHARS
+  可见字截断并注明去原文看；它是书级设定，优先于作者记忆。
+- 主会话填九个固定槽：执行安排 / 本章意图 / 作者本轮要求 / 本章技法 / 本节速记 / 涉及角色 /
+  genre_prose_card / 必读设定 / style_resolution。另有两个条件槽，出现时同样标［主会话填］：
+  author_preferences 块内的限定范围（--genre／--workflow）作者记忆未代查时，由主会话判断是否适用后补查
+  （脚本查询失败时则整块手查）；降档不成立时「情绪与节奏召回」也归主会话。
+  核对报告末尾的「待填槽位」给出本次实际个数（9-11）。
+  材料槽对应原流程步骤 3「写前准备」的四项输出（本节速记 / 目标情绪 / 涉及角色 /
+  本章技法）加上作者本轮要求、题材卡、设定补漏与作者偏好——都是判断，脚本做不了。
 - 续写状态卡校验后由主会话筛选，在「本节速记」槽内写入本章需要的状态。
 - 可选块缺失留标题并写明原因（「没有」与「漏了」在产物上必须长得不一样）。
   必在块缺失退出码 2 —— 那是数据问题，要修数据后重跑，不是回落手拼的理由。
@@ -23,7 +34,9 @@ Exit: 0 = 骨架已输出；2 = 输入缺失或无效。
 
 import argparse
 import io
+import json
 import re
+import subprocess
 import sys
 from pathlib import Path
 from outline_view import parse as parse_volume
@@ -31,6 +44,14 @@ from outline_view import parse as parse_volume
 TAIL_CHARS = 400          # 上一章结尾注入的目标字符数（按整行回退，不切半句）
 STATE_SECTIONS = ("当前位置", "长期约束", "核心角色状态", "活跃伏笔", "近三章速记", "下一章承诺", "连贯性风险")
 SLOT_MARK = "［主会话填］"
+AUTHOR_DECIDED_CHARS = 600  # 「作者已定」注入上限（去空白字数）；超了截断，写手按提示回原文看
+WORK_ROOT = (".story", "work")
+
+
+def chapter_work_dir(project: Path, chapter: int) -> Path:
+    """本章临时文件的唯一落点；与 storyctl.py 提交后清理的目录同一口径。"""
+    width = max(3, len(str(chapter)))
+    return project.joinpath(*WORK_ROOT, f"第{chapter:0{width}d}章")
 
 
 def read_text(path: Path):
@@ -58,7 +79,7 @@ def find_chapter_file(directory: Path, chapter: int, prefix: str):
         return None
     pattern = re.compile(rf"^{prefix}第0*{chapter}章.*\.md$")
     for entry in sorted(directory.iterdir()):
-        if entry.is_file() and pattern.match(entry.name):
+        if entry.is_file() and pattern.match(entry.name) and "_原稿_" not in entry.name:
             return entry
     return None
 
@@ -125,6 +146,135 @@ def previous_chapter_tail(project: Path, chapter: int):
     return prev, "\n".join(reversed(picked))
 
 
+MEMORY_KINDS = ("prose_style", "story_design")
+# 限定「流程」的作者记忆里，这些取值指的就是长篇写正文。
+LONG_WRITE_WORKFLOWS = {"长篇", "长篇写作", "写长篇", "长篇连载", "长篇网文", "长篇正文", "story-long-write"}
+
+
+def scoped_memory_values(workspace: Path):
+    """项目级 store 里限定题材／流程的 active 条目取值：{"genre": {...}, "workflow": {...}}。"""
+    values = {"genre": set(), "workflow": set()}
+    state = read_text(workspace / ".story" / "作者记忆" / "_author-memory-state.json")
+    try:
+        items = (json.loads(state) if state else {}).get("items") or {}
+        items = list(items.values())
+    except (ValueError, AttributeError, TypeError):
+        return values
+    for item in items:
+        if not isinstance(item, dict):
+            continue
+        scope = item.get("scope") if isinstance(item.get("scope"), dict) else {}
+        if (item.get("status") == "active" and item.get("kind") in MEMORY_KINDS
+                and scope.get("level") in values and scope.get("value")):
+            values[scope["level"]].add(scope["value"])
+    return values
+
+
+def genre_line(project: Path):
+    """「题材类型」行的原文；未填的模板占位（{…}）当没有。"""
+    text = read_text(project / "设定" / "题材定位.md") or ""
+    match = re.search(r"^[ \t]*[-*+]?[ \t]*\**题材(?:类型)?\**[ \t]*[：:](.*)$", text, re.M)
+    if not match or "{" in match.group(1):
+        return ""
+    return match.group(1).strip()
+
+
+def book_genres(project: Path):
+    """「题材类型」行按分隔符切成词。"""
+    return {word.casefold() for word in re.split(r"[\W_丨×]+", genre_line(project)) if word}
+
+
+GENRE_CARD_DIR = Path(__file__).resolve().parent.parent / "references" / "genre-prose-cards"
+
+
+def match_genre_cards(project: Path):
+    """题材正文提示卡缺失时，按「题材类型」原文匹配题材卡（卡头的 genre 与 aliases），替主会话省掉整读索引。
+
+    按在题材类型里出现得越靠前越优先（主题材在前），同位置按置信度高→低；最多返回主、辅两张：[(路径, 置信度)]。"""
+    raw = genre_line(project).casefold()
+    if not raw or not GENRE_CARD_DIR.is_dir():
+        return []
+    rank = {"high": 0, "medium": 1, "low": 2}
+    hits = []
+    for card in sorted(GENRE_CARD_DIR.glob("*.md")):
+        head = (read_text(card) or "").split("---")
+        meta = head[1] if len(head) > 2 else ""
+        genre = re.search(r"^genre:\s*(.+)$", meta, re.M)
+        aliases = re.search(r"^aliases:\s*\[(.*)\]", meta, re.M)
+        confidence = re.search(r"^confidence:\s*(\w+)", meta, re.M)
+        names = [genre.group(1).strip()] if genre else [card.stem]
+        names += [a.strip() for a in aliases.group(1).split(",")] if aliases else []
+        where = [raw.find(name.casefold()) for name in names if name and name.casefold() in raw]
+        if where:
+            level = confidence.group(1) if confidence else "low"
+            hits.append((min(where), rank.get(level, 2), card, level))
+    hits.sort(key=lambda row: (row[0], row[1], row[2].name))
+    return [(card, level) for _, _, card, level in hits[:2]]
+
+
+def author_decided(project: Path):
+    """`设定/题材定位.md`「## 作者已定」一节：去掉模板占位行；返回 (正文, 是否截断)。没有这一节返回 (None, False)。"""
+    text = read_text(project / "设定" / "题材定位.md") or ""
+    match = re.search(r"^##[ \t]*作者已定[^\n]*\n(.*?)(?=^#{1,2}[ \t]|\Z)", text, re.M | re.S)
+    if not match:
+        return None, False
+    lines = [line.rstrip() for line in match.group(1).splitlines()
+             if line.strip() and not re.fullmatch(r"\s*[-*+]?\s*\{.*\}\s*", line)]
+    kept, used, cut = [], 0, False
+    for line in lines:
+        size = len(re.sub(r"\s", "", line))
+        if used + size > AUTHOR_DECIDED_CHARS:
+            cut = True
+            break
+        kept.append(line)
+        used += size
+    return "\n".join(kept), cut
+
+
+def query_author_memory(project: Path):
+    """代主会话做写正文那一次作者记忆查询（prose_style + story_design，每次 ≤2KB）。
+
+    工作区取书目录及其祖先里第一个带 `.story-deployed` 的目录；找不到就把书目录当工作区。
+    限定题材的条目只在取值出现在本书「题材类型」里时代查，限定流程的只认长篇写作的取值；
+    其余限定条目不猜，报给主会话自己判断。
+    返回 (条目列表, 超编 ID 列表, 未代查的限定取值, 错误)；错误时由主会话按 author-memory.md 手动查询。
+    """
+    workspace = next((d for d in (project, *project.parents) if (d / ".story-deployed").is_file()), project)
+    script = Path(__file__).with_name("author_memory_commit.py")
+    if not script.is_file():
+        return None, [], {}, "author_memory_commit.py 缺失"
+    scoped = scoped_memory_values(workspace)
+    book = book_genres(project)
+    genres = sorted(v for v in scoped["genre"] if v.casefold() in book) or [None]
+    workflows = sorted(v for v in scoped["workflow"] if v.casefold() in {w.casefold() for w in LONG_WRITE_WORKFLOWS})
+    skipped = {"genre": sorted(v for v in scoped["genre"] if v not in genres),
+               "workflow": sorted(v for v in scoped["workflow"] if v not in workflows)}
+    items, omitted, seen = [], [], set()
+    for genre in genres:
+        for workflow in workflows or [None]:
+            command = [sys.executable, str(script), "query", "--workspace", str(workspace), "--book-root", str(project)]
+            for kind in MEMORY_KINDS:
+                command += ["--kind", kind]
+            if genre:
+                command += ["--genre", genre]
+            if workflow:
+                command += ["--workflow", workflow]
+            completed = subprocess.run(command, capture_output=True, text=True, encoding="utf-8", check=False)
+            try:
+                result = json.loads(completed.stdout or "{}")
+            except ValueError:
+                result = {}
+            if not result.get("ok"):
+                return None, [], {}, result.get("error") or completed.stderr.strip() or "query 失败"
+            for item in result.get("items") or []:
+                if item.get("id") not in seen:
+                    seen.add(item.get("id"))
+                    items.append(item)
+            omitted += [i for i in result.get("omitted_ids") or [] if i not in omitted and i not in seen]
+    omitted = [i for i in omitted if i not in seen]
+    return items, omitted, {k: v for k, v in skipped.items() if v}, None
+
+
 def learn_heading_form(project: Path, chapter: int, title: str):
     """从已有正文学标题行形态（层级／章号填充位数／分隔符），不按通用规则推导。
 
@@ -233,7 +383,7 @@ def build(project: Path, chapter: int, report: list):
         parts.append(
             "——— 文风 ———\n"
             "（本书无可用的 设定/文风.md，未进入自定义文风模式；"
-            "按 workflow-chapter 3(d) 走对标文风召回，由主会话补路径与召回指令）")
+            "按 benchmark-recall.md 走对标文风召回，由主会话补路径与召回指令）")
         report.append("文风：custom_style=false，文风召回归主会话（未跳过，留标题）")
 
     # ---- 上一章结尾（不给路径，避免写手回头读整章）----
@@ -277,7 +427,10 @@ def build(project: Path, chapter: int, report: list):
     needs = {"题材正文提示卡": card_text, "目标情绪": target_emotion,
              "单元情绪引擎": engine, "单元节拍/章功能分配": tempo}
     why = [name + "缺有效内容" for name, value in needs.items() if not substantive(value)]
-    if not custom_style:
+    # 无对标（项目与工作区都没有对标书）时文风本就没有对标可召回：不因 custom_style 缺失拒绝降档
+    no_benchmark = not any(d.is_dir() for base in (project / "对标", project / "拆文库", project.parent / "拆文库")
+                           if base.is_dir() for d in base.iterdir())
+    if not custom_style and not no_benchmark:
         why.append("custom_style=false")
     downgrade = not why
 
@@ -292,28 +445,33 @@ def build(project: Path, chapter: int, report: list):
         if tempo:
             lines.append(f"  {tempo}")
         slot_recall = "——— 情绪与节奏召回 ———\n" + "\n".join(lines)
-        report.append(f"召回降档：成立，文风、题材卡、目标情绪和单元 {unit_id} 情绪/节拍均可用")
+        report.append(f"召回降档：成立，{'无对标，' if no_benchmark and not custom_style else '文风、'}题材卡、目标情绪和单元 {unit_id} 情绪/节拍均可用")
     else:
         slot_recall = ("——— 情绪与节奏召回 ———\n"
                        f"{SLOT_MARK} 降档不成立（" + "、".join(why) +
-                       "），按 workflow-chapter 3(a)(b)(e)(f) 走全量召回后填此槽")
+                       "），按 benchmark-recall.md 走全量召回后填此槽")
         report.append("召回降档：不成立（" + "、".join(why) + "）—— 全量召回归主会话")
 
     # ---- 需要主会话判断的槽位 ----
+    work_dir = chapter_work_dir(project, chapter)
     parts.append(
         "——— 执行安排 ———\n"
         f"{SLOT_MARK} 全章细纲用于整体编排。默认按自然转场或因果停顿分前后两组，"
-        "填写当前组的情节点/片段及临时输出路径；先只写前组，父流程测一次 checkpoint 后"
-        "再给后组和机器剩余区间。只有用户明确要求一次成文时才填「全章，直接写最终路径」。")
+        "填写当前组的情节点/片段；先只写前组，主会话测一次 checkpoint 后"
+        "再给后组和机器剩余区间。只有用户明确要求一次成文时才填「全章，直接写最终路径」。\n"
+        f"分组临时文件：前组 {work_dir / '前组.md'}，后组 {work_dir / '后组.md'}"
+        "（只写这里，不写 /tmp 或 正文/）。")
     parts.append(f"——— 本章意图（一句话）———\n{SLOT_MARK}")
+    parts.append("——— 作者本轮要求 ———\n"
+                 f"{SLOT_MARK} 作者这次明确说的：字数范围、必须发生、不许发生、写到哪里停、章尾要留什么；没有写「无」。")
     parts.append(slot_recall)
     # 伏笔与卷级禁忌走「主会话筛选后写进速记」这条原设计路线（步骤 3 状态筛选），
     # 不由脚本整栏注入——筛选是判断，而整栏注入还会把伏笔栏里的作者侧真相一并下放。
     # 代价是它依赖主会话逐章想起来，所以这里把提示语写成写死的三问清单。
     parts.append(
-        "——— 参考技法 ———\n"
-        f"{SLOT_MARK} 步骤 3 三问的第 ②③ 问：借鉴哪个参考文件的哪个技法、用在哪些段落。"
-        "按 reference 表的任务条件读取；本书文风只覆盖冲突表达条款，不停读整份文件。")
+        "——— 本章技法 ———\n"
+        f"{SLOT_MARK} 按细纲主功能填 打脸／反转／感情／悬疑／日常／无 之一（对照 SKILL.md「本章技法」），"
+        "再写一句用在哪几段；写手按自己的读取表读对应文件，这里不摘技法。本书文风只覆盖冲突表达条款，不停读整份文件。")
     parts.append(
         "——— 本节速记 ———\n"
         f"{SLOT_MARK} 按 workflow-chapter 步骤 3「状态筛选」产出（`追踪/上下文.md` 不注入"
@@ -325,18 +483,53 @@ def build(project: Path, chapter: int, report: list):
         "——— 涉及角色 ———\n"
         f"{SLOT_MARK} 按细纲「人物出场顺序」与「镜头准入」的台词位／动作位分配，"
         "列出本章要读的角色卡；本节速记已给全状态的不必再列。")
+    if not substantive(card_text):
+        cards = match_genre_cards(project)
+        if cards:
+            named = "；".join(f"{'主' if i == 0 else '辅'}题材 {card}（置信度 {level}）" for i, (card, level) in enumerate(cards))
+            report.append(f"题材卡：本书还没有题材正文提示卡，按「题材类型」匹配到 {named}；生成后落盘，后续章直接读")
+        else:
+            report.append("题材卡：本书还没有题材正文提示卡，题材卡无匹配——读 style-genre-modules.md"
+                          "「题材正文提示卡」一节与最接近的流派一节生成后落盘")
     parts.append("——— 题材正文提示卡（genre_prose_card，只含本章相关条目）———\n"
                  f"{SLOT_MARK} 主题材抽 3-5 条、辅题材 1-2 条；只作内部校准，不进正文")
     parts.append(slot_setting)
-    parts.append("——— style_resolution / author_preferences ———\n"
-                 f"{SLOT_MARK} author_memory query 命中本章的 prose_style/story_design 项；"
-                 "query 显式传本书/题材/流程；偏好是低优先级倾向，无则写「无」。附 style_resolution：生效要求及来源、被覆盖的默认条款和事实边界；同一裁决传去味与审稿，不逐条追求命中。")
-
-    parts.append("检查分工：写手负责编排、内容覆盖和格式自检；父流程质量阶段负责语义去味及最终文件扫描。写手不提前重复整轮去味或相同检查链，保留时空表、新增申报与原定交付。")
+    decided, cut = author_decided(project)
+    if decided:
+        note = (f"\n（超过 {AUTHOR_DECIDED_CHARS} 字已截断，其余见 {project / '设定' / '题材定位.md'}「作者已定」，动笔前读完）"
+                if cut else "")
+        parts.append("——— 作者已定（本书的决定，高于作者记忆，与细纲冲突以细纲为准并在交付摘要里说明）———\n"
+                     + decided + note)
+        report.append("作者已定：已注入" + ("（超长截断，写手需回原文读完）" if cut else ""))
+    else:
+        report.append("作者已定：题材定位里没有或为空，未注入")
+    items, omitted, skipped, memory_error = query_author_memory(project)
+    if memory_error:
+        memory_block = (f"{SLOT_MARK} 组装脚本查询作者记忆失败（{memory_error}），"
+                        "按 author-memory.md 手动 query prose_style + story_design 后填入；无则写「无」")
+        report.append(f"作者记忆：脚本查询失败——{memory_error}，归主会话手动查询")
+    elif items:
+        memory_block = "\n".join(f"- {item.get('assertion', '').strip()}（{item.get('id', '')}）" for item in items)
+        report.append(f"作者记忆：已注入 {len(items)} 条" + (
+            f"；超编未装下 {len(omitted)} 条（{'、'.join(omitted)}），转告作者建议「整理作者记忆」" if omitted else ""))
+    else:
+        memory_block = "无"
+        report.append("作者记忆：无相关 active 条目")
+    if skipped and not memory_error:
+        named = "；".join(f"{'题材' if k == 'genre' else '流程'}：{'、'.join(v)}" for k, v in skipped.items())
+        memory_block += (f"\n{SLOT_MARK} 另有限定范围的作者记忆未代查（{named}）：本书适用的，"
+                         "带 --genre／--workflow 跑 SKILL.md「核心方法」的 query 命令（--kind prose_style --kind story_design）后补进本块")
+        report.append(f"作者记忆：限定范围未代查（{named}），归主会话判断是否适用")
+    parts.append("——— author_preferences（作者记忆，低优先级倾向，不逐条追求命中）———\n" + memory_block)
+    parts.append("——— style_resolution ———\n"
+                 f"{SLOT_MARK} 本轮请求里作者对表达的明确要求及其覆盖的默认条款（没有写「无」）；"
+                 "本书文风与作者记忆的裁决见上方各块，同一裁决传去味与审稿。")
+
+    parts.append("检查分工：写手负责编排、内容覆盖和格式自检；主会话质量阶段负责语义去味及最终文件扫描。写手不提前重复整轮去味或相同检查链，保留情节点落点、新增申报与原定交付。")
 
     # ---- 固定块：压成指针，不重述 agent 定义 ----
     parts.append(
-        "本次照你的铁律 1-8 与被调用协议执行（细纲优先边界、正文形状、新增物三档、"
+        "本次照你的铁律 1-8 与被调用协议执行（细纲优先边界、正文形状、新增物三级、"
         "阅读体验字段、交付三附件均以你的定义为准，此处不重述）。")
     parts.append(
         "字数目标按细纲执行，字数口径 visible_chars_v1；按执行安排交付，"
@@ -360,7 +553,8 @@ def main(argv=None):
     parser = argparse.ArgumentParser()
     parser.add_argument("--project", required=True)
     parser.add_argument("--chapter", required=True, type=int)
-    parser.add_argument("--out", default=None)
+    parser.add_argument("--out", nargs="?", const="", default=None,
+                        help="prompt 留档路径；不带值时留档到本章工作目录 writer_prompt.md")
     args = parser.parse_args(argv)
 
     project = Path(args.project).resolve()
@@ -391,9 +585,16 @@ def main(argv=None):
             f"标题预检：《{title}》" + ("与既有章重名 → " + "、".join(clashes)
                                        if clashes else "无重名"))
 
-    if args.out:
-        io.open(args.out, "w", encoding="utf-8", newline="\n").write(prompt)
-        report.append(f"留档：{args.out}")
+    if args.out is not None:
+        out = Path(args.out) if args.out else chapter_work_dir(project, args.chapter) / "writer_prompt.md"
+        try:
+            out.parent.mkdir(parents=True, exist_ok=True)
+            with io.open(out, "w", encoding="utf-8", newline="\n") as handle:
+                handle.write(prompt)
+        except OSError as exc:
+            sys.stderr.write(f"留档写入失败：{out}（{exc}）\n")
+            return 2
+        report.append(f"留档：{out}")
 
     sys.stdout.write(prompt)
     sys.stdout.write("\n" + "=" * 60 + "\n")