提示词分级：规则与生成结合的层次化提示工程

摘要

大语言模型 Agent 的提示词实践长期陷入扁平化困境：系统指令、任务背景、历史轨迹、工具结果、用户输入统统塞进一个 prompt，导致前缀缓存失效、复用率趋零、维护成本高企、输出不可控。本文指出，这一困境的本质并非措辞不精，而是根因未被识别 ------"分级"不是可选的写作优化，而是由两个前提条件共同触发的结构性必然：循环（多轮迭代执行）与 Agent（自主、工具调用、目标驱动的运行形态）。二者单独存在皆不足以使分级成为必需：单轮无缓存可命中；循环无自主性则单模板即足；Agent 单步则无跨轮累积。唯有循环 × Agent 交汇，才张开"进程-任务-步骤"三种嵌套时间尺度，才使 L0（进程级常量）/ L1（任务级）/ L2（步骤级）的三级稳定性切分从"锦上添花"变为"承重结构"。扁平 prompt 的四重困境，本质正是这一根因在场而未被识别时的表征。

据此，本文提出"提示词即分层架构"的核心理念与三原则，给出 L0/L1/L2 分级模型、成本数学模型与端到端数据流；从分层架构（Parnas 1972、Dijkstra 1968）、缓存局部性（Denning 1968/2005）、分布式认知（Hutchins 1995）、提示工程文献（Wei 2022、Brown 2020、Wu 2022）、神经-符号混合（Garcez & Lamb 2020）等视角论证其合理性；对照 OpenAI、LangChain、Semantic Kernel、Claude、LlamaIndex、Prompt Chaining 等方案阐明本框架的贡献；最后给出工程落地与更深意义。

核心结论：只有循环与 Agent 同时在场，分级才是承重的；识别这一根因，是从"提示词工程"到"提示词系统工程"范式跃迁的前提。

关键词：提示词分级；循环与 Agent；层次化提示工程；前缀缓存；三时间尺度；规则与生成结合；Agent 工程化

一、根本动因：循环与 Agent 何以使分级成为必然

1.1 分级是结构性必然，而非普遍最佳实践

一个被广泛持有的隐含假设是：提示词分级是一种适用于任何场景的"写作技巧精进"。本文的第一个主张是反驳这一假设------分级并非普遍最佳实践，而是由两个前提条件共同触发的结构性必然 ：循环（multi-turn iterative execution，多轮迭代执行）与 Agent（autonomous, tool-calling, goal-directed operation，自主、工具调用、目标驱动的运行形态）。当且仅当二者同时在场时，分级才从"可选优化"变为"承重结构"。本章的任务是把这一充分且必要条件论证清楚------它是全文的地基，后续所有论证（成本模型、稳定性切分、缓存局部性、学术基础）皆是这一根因在不同维度的投影。

1.2 三段反证：单条件皆不需分级

必要性的最严格论证是反证------逐一剥离前提，观察分级是否仍属必需。

反证一：单轮场景无需分级。 当 N=1（一次性问答、单次翻译、单次摘要）时，不存在可被反复命中的前缀，缓存归因失去意义。4.5 节的成本模型将给出反证：N=1 时扁平方案更便宜，分级方案因 L1 生成的一次性开销反而贵约 24%。没有重复调用，就没有"工作集"（working set）可稳定，就没有 0.1 倍缓存价差可捕获------此时"省着用"（压缩/截断）已足够，"循环用"（缓存/复用）无从谈起。分级的全部经济性根植于"N≥2"这一前提，而 N≥2 的来源正是循环。

反证二：循环单独存在（固定流水线）亦无需三级。 若一条流水线步骤固定、每轮结构相同（如批处理 1000 个文件，每文件走相同的"读取-转换-写出"三步），则单一模板即可覆盖全部迭代，无需区分任务级与步骤级。循环但无自主性 = 批处理，其"步"是预设的而非由上一步结果动态决定------L2 的 rule_needs_replan 兜底无从触发，L1 的"一次任务只理解一次"也无对象可摊销。一个固定模板层就足以承载，三级切分对固定流水线是过度设计。这里的关键是区分两类循环：固定循环（fixed loop，步预设）只需一层模板；自适应循环（adaptive loop，步由上一步结果决定）才需要步骤级的动态调度，而自适应循环正是 Agent 的特征。

反证三：Agent 单独存在（单步）同样无需分级。 若 Agent 仅执行一次工具调用即返回（N=1 的自主调用），动态上下文尚未累积，前缀尚未被破坏，扁平 prompt 与分级 prompt 在成本与可控性上几乎无差。"动态工具结果摧毁缓存"这一问题只有在跨轮累积时才显形------单步 Agent 没有跨轮，也就没有缓存被破坏的痛点。Agent 的自主性、工具调用、目标导向在单步场景下并未制造出需要分层治理的张力。

三段反证收敛到同一结论：循环与 Agent，缺一不可。 去掉循环，分级的经济性消失；去掉 Agent，分级的结构性消失。

1.3 循环 × Agent：四股力量的交汇

Agent 按定义就是"面向目标的多步工具调用循环"------它不是单次推理，而是"感知-决策-行动-观察"的迭代闭环（Yao et al. 2022, ReAct；Wu et al. 2022, AI Chains）。这一本质同时点燃了四股力量，且只有四者并存时才共同要求分级：

力量	触发条件	对分级的诉求	对应层级
重复调用产生缓存机会	循环	必须有可冻结的稳定前缀去捕获 0.1 倍价差	L0 / L1 可分离并固化
动态无界的工具结果	Agent 的工具调用	必须把易变内容隔离到尾部，不污染前缀	L2 作为倾倒区
跨轮的身份与契约持久	Agent 的自主性	角色/安全/格式必须超越任何单步存活	L0 进程级不变式
任务内的目标承诺	Agent 的任务导向	目标必须超越单步但不超越任务	L1 任务级指引

逐行解读这四股力量如何各自依附于循环或 Agent：

第一股（缓存机会）只来自循环。 单轮无重复，无重复则缓存无对象。循环使同一前缀被反复访问，创造了 Denning（1968）工作集模型所指的"时间局部性"------这正是前缀缓存折扣的经济来源。
第二股（动态工具结果）只来自 Agent。 工具调用的返回值是外生的、无界的、不可预测的------这是 Agent 区别于固定流水线的本质。固定流水线的"步"是预设的，内容可被模板预编码；Agent 的"步"由工具结果动态决定，内容无法预编码，只能作为易变内容隔离在 prompt 尾部，否则会污染前缀、摧毁缓存。
第三股（身份持久）来自 Agent 的自主性。 一个自主的 Agent 必须在跨轮次中保持一致的角色、安全边界、输出格式------否则它就不是"一个 Agent"而是"一连串互不相关的调用"。这种"超越单步存活"的契约必须锚定在最稳定的层（L0），使其不随任何单步变化。
第四股（目标承诺）来自 Agent 的任务导向。 Agent 朝一个目标推进，目标在一次任务内不变、跨任务则变。这种"超越单步但不超越任务"的中间稳定性需要一个独立层级（L1）承载------它比 L0 易变（跨任务要换），又比 L2 稳定（任务内不变）。

四股力量并非偶然地正好投影到三个稳定性层级------它们的交汇恰好张开了三种嵌套时间尺度，这是下一节的核心。

1.4 三种嵌套时间尺度：分级结构的几何骨架

循环 × Agent 所张开的，是三种嵌套的时间尺度：

L0 ≈ 进程生命周期（process lifetime）：身份、安全、输出格式。跨任务、跨轮次持久。一个 Agent 进程从启动到终止，L0 不变。
L1 ≈ 任务生命周期（task lifetime）：目标、意图、约束。跨步骤持久，但不跨任务。一个任务从接收到完成，L1 不变；新任务到来则 L1 重新生成。
L2 ≈ 步骤生命周期（step lifetime）：当前动作、上步反馈。每步刷新。一次工具调用前后，L2 即变。

这三种尺度是嵌套的：进程 ⊃ 任务 ⊃ 步骤。L0 的生命周期包含多个 L1 的生命周期，L1 的生命周期包含多个 L2 的生命周期。这种嵌套结构直接决定了层间的依赖方向：L1 可引用 L0 的不变式，L2 可引用 L0 与 L1 的契约，但反向不可------上层不感知下层具体内容，只通过约定槽位接收数据。这与 Meyer（1992）契约式设计的前置条件、后置条件、不变式三段论同构。

为什么是三级，而非两级或四级？ 因为循环 × Agent 恰好张开三种尺度。若只考虑循环（无 Agent），只有"进程 + 步骤"两尺度------进程级常量 + 步骤级模板，两层即足（反证二）；若只考虑 Agent（无循环，单步），只有"进程 + 任务"两尺度------进程级身份 + 任务级目标，无需步骤级（反证三）；若强行加一级（如"子任务级"），则该级缺乏独立的时间尺度支撑------子任务的生命周期要么被任务级吸收，要么被步骤级吸收，无法稳定地独立存在。三级是这一根因下的最小完备切分，既无冗余也无缺失。

这一节给出了分级结构的"几何骨架"：三层 = 三种嵌套时间尺度 = 循环 × Agent 的必然投影。后续章节的所有内容------稳定性递减原则、缓存策略、成本模型、规则与生成的边界------都是挂在这副骨架上的血肉。

1.5 反事实验证：剥离任一条件，分级即坍缩

为强化"充分且必要"的论证，设想两种剥离实验：

剥离循环（Agent 退化为单步工具调用）：分级的经济性消失。N=1，扁平更便宜；L1 生成开销无法摊销；前缀缓存无重复访问可命中。此时分级从"承重"降为"可选装饰"------即便强行分层，也只省下无关紧要的边际成本。这对应反证一与反证三的叠加。
剥离 Agent（系统退化为固定流水线） ：分级的结构性消失。L1/L2 边界坍缩为单一模板------没有动态工具结果需要隔离，没有 rule_needs_replan 需要触发，没有任务级与步骤级的稳定性差异。此时三级切分是过度设计，一个固定模板层即足。这对应反证二。

两种剥离都使分级失去承重作用，反向印证：循环与 Agent 是分级必要性的充分且必要条件。 这一结论具有工程判别力------面对一个新系统，先问两个问题：它是否多轮？它是否自主工具调用？若任一为否，分级不是必需（可能仍有边际收益，但不承重）；若二者皆为是，则分级是不可绕过的工程前提。这一判别准则把"是否要分级"从主观判断转化为可回答的二值决策。

1.6 根因的统合力：全文论证的三重显形

这一根因并非新立论，而是把全文既有论证收束到一个支点上。后续章节从三个维度展开，三者皆是同一根因的投影：

成本轴（4.5 节）：成本模型的 N* 阈值（N≥2 时分级占优），是"循环"在成本维度的显形------循环创造 N≥2，N≥2 使缓存摊销成立。
结构轴（3.2 节）：稳定性递减原则的三级切分，是"循环 × Agent"在结构维度的显形------三时间尺度要求三稳定性层级。
缓存轴（5.2 节）：缓存局部性原理之所以成立，正是因为"循环"创造了使局部性有价值的重复访问模式；没有循环，局部性退化为随机访问，缓存形同虚设。

去掉循环与 Agent，三条论证同时失效；保留二者，三条论证同时成立。分级不是三项独立优点的叠加，而是单一根因的三重显形。 这也解释了常见现象：分级在原型期（单轮、无 Agent）总显得"多此一举"，而一旦进入生产期（多轮、Agent 化）便成为不可绕过的工程前提------根因的在场与否，决定了分级是装饰还是承重。

二、病征重读：扁平化困境是根因未识别的表征

第一章确立了根因。本章重读业界熟知的"扁平化困境"------它不是独立故障，而是根因在场而未被识别时的表征。当系统已处于循环 × Agent 的场景（根因在场），却仍采用扁平 prompt（未识别根因），四重困境便必然显现。

2.1 扁平化 prompt 的四重困境

工程实践中最普遍的提示词形态是"扁平化"------一个 prompt 里同时承载系统角色定义、任务目标、历史交互、工具调用结果、用户原始指令、输出格式要求。这种"一锅烩"在原型阶段似乎无伤大雅，但一旦进入多轮、多任务的生产环境（即循环 × Agent 在场），便暴露出四重叠加的困境：

前缀缓存失效 。主流 API 提供商的自动前缀缓存要求前缀逐 token 一致。扁平 prompt 中，动态上下文（历史轨迹、工具结果）紧跟在系统指令之后，第二轮起前缀即被破坏，缓存命中率随轮次增加急剧下降。本可只付 0.1 倍价格的静态部分，被迫按全价反复计费。这是循环创造的缓存机会被扁平结构浪费。
复用率趋零 。任务级与步骤级信息纠缠在一起，没有任何一块可独立抽取出来在新任务中复用。相似任务到来时，系统只能从零重写整个 prompt，无法摊销历史投入。这是三时间尺度未被切分导致的复用粒度缺失。
维护成本高企 。角色定义、输出格式、安全规则、任务逻辑、步骤细节散落在同一文本中，任何一处调整都可能波及其余，提示词演化成为高风险操作。这是三层稳定性未被分离导致的变更波及。
输出不可控 。约束指令与动态数据混杂，模型注意力被大量变量信息稀释，末尾的"输出格式""禁止解释"等死命令极易在长上下文中被淹没。这是 L0 强区位被动态内容侵占的结果。

2.2 因果链：扁平化如何自我强化

这四重困境并非独立故障，而是同一病根------根因未识别 ------的不同表征。它们之间存在自我强化的负反馈：扁平化导致缓存失效，缓存失效推高单次成本，高成本迫使开发者压缩输入，压缩又进一步把约束与数据挤压在一起，加剧输出失控。值得注意的是，这个"负反馈循环"本身就是循环------它和第一章的"循环"同构：系统越是多轮，扁平化的代价越大；代价越大，开发者越是想压缩，压缩又加剧失控。根因（循环）既制造了分级的必要性，也制造了不分级时的自我恶化。

2.3 成本视角：前缀缓存的命中与失效

从 Token 成本视角切入更为锋利。Agent 的 Token 成本可分解为（参考《从"省着用"到"循环用"》一文）：

复制代码

C = Σ (i=1..N) [ p_in · l_in(i) + p_out · l_out(i) ]

其中 p_out ≈ 3 × p_in，且前缀缓存命中部分按 0.1 × p_in 计费。由此得到两个关键事实：

System Prompt 固化命中前缀缓存：静态前缀稳定不变时，其输入成本降至 0.1 倍。
动态上下文不命中缓存：多轮工具调用中每次返回的观察结果不同，破坏缓存连续性，动态部分始终按全价计费。

扁平 prompt 的根本错误在于：把"本可固化、本应命中 0.1 倍缓存的稳定指令"与"注定不命中缓存的动态上下文"物理粘合，使稳定部分被动态部分拖累，整体失去缓存资格。用根因语言重述：扁平 prompt 让 L0、L1、L2 三种时间尺度的内容物理粘合，使本应跨进程持久的 L0、本应跨步骤持久的 L1，都被每步刷新的 L2 拖累。

举一个具体场景：假设系统指令 2000 token、任务说明 1500 token、累积的历史与工具结果在第 1/2/3 轮分别为 500/2000/4000 token。扁平 prompt 把三者顺序拼接，第 1 轮前缀为"系统+任务+历史500"，第 2 轮变为"系统+任务+历史2000"------前缀在第 3501 token 处即分叉，缓存仅覆盖前 3500 token（系统+任务，若提供商按最长公共前缀匹配）。又因扁平设计常把动态内容夹在稳定内容之间，最长公共前缀可能只有系统指令的前几百 token。分级设计则把 L0、L1 物理前置并固化，动态的 L2 放在最末，使最长公共前缀稳定覆盖 L0+L1 共 3500 token，缓存资格最大化。

2.4 优先级倒置：成本权重的再提醒

成本优化的优先级排序为"轮次＞输出＞输入"。扁平 prompt 恰恰在第一杠杆上处于劣势：各层逻辑耦合，单层调整往往需重新生成整个 prompt，间接增加调用轮次；输出又因不可控而在长上下文稀释下膨胀。提示词分级并非仅为了"压缩输入"------这是常见的误解------而是通过分层把稳定部分剥离出去命中缓存、把生成部分收敛到必要环节，从而同时改善输入、输出与轮次三个维度，三者的改善是协同而非互斥的。用根因语言说：循环（轮次）是第一杠杆，而循环正是分级的触发条件之一------分级首先改善的，恰恰是根因本身。

2.5 一个被忽视的诊断信号

判断一个 Agent 系统是否陷入扁平化困境（即是否未识别根因），有一个简单信号：问"你的系统提示词在前缀缓存中占多少 token？"。若回答含糊或从未测量过缓存命中率，则系统几乎必然在为扁平化付出隐性税。分级框架的第一步不是重构 prompt，而是建立缓存归因的可观测性------先量度，再分层。

更进一步的诊断信号是两个二值问题：你的系统是否多轮？你的系统是否自主工具调用？ 若二者皆为是，则根因在场，分级是承重结构；若任一为否，则分级非必需（详见 1.5 节判别准则）。这两个问题把"是否需要分级"从直觉判断升级为可回答的工程判据。

三、核心理念：提示词即分层架构

3.1 从"一锅烩"到"分趟 pass"

分层是计算机科学应对复杂性的经典武器。OSI 网络模型把通信分解为七层，每层只对邻层负责；MVC 把交互系统分为模型、视图、控制器；编译器把源语言到目标代码的翻译分解为词法、语法、语义、优化、代码生成等多个"趟"（pass）。每一层（每一趟）职责单一、接口明确、可独立演化。

经典分层体系	分层依据	与提示词分级的同构
OSI 七层模型	抽象层级（物理→应用）	提示词按抽象层级：角色（L0）→任务（L1）→动作（L2）
MVC	关注点（数据/展示/控制）	提示词按关注点：不变式（L0）/目标（L1）/调度（L2）
编译器多趟	处理阶段	提示词按生命周期阶段：进程级/任务级/步骤级
软件模块化（Parnas）	变化方向	提示词按变化频率：稳定/中频/高频

提示词同样可被视作一种"分层系统"。第一章已论证，循环 × Agent 张开了进程-任务-步骤三种时间尺度；本节的同构表则显示，这三种尺度与经典分层体系一一对应。把三种稳定性迥异的信息强行堆叠，等于让最易变的部分污染最稳定的部分。分层的本质，是按稳定性对信息进行正交分解，使每一层都能采取最适合自身的治理策略。

3.2 分层三原则

提示词分级遵循三条原则，每一条都锚定在第一章的根因上：

稳定性递减原则 ：从 L0 到 L2，层的稳定性单调递减。L0 最稳定（进程级常量），L1 次之（任务级，一次任务内不变），L2 最易变（步骤级，每步刷新）。稳定性高的层刷新频率低，因而适合固化与缓存。这一原则是"三时间尺度"（1.4 节）的直接转写------时间尺度越长，稳定性越高。它对应 Parnas（1972）的"按预期变化方向划分模块"。
职责单一原则 ：每一层只承担一种关注点。L0 定义"我是谁、边界在哪、输出长什么样"；L1 定义"这次任务做什么、约束是什么"；L2 定义"这一步具体怎么走"。层与层之间不重复、不越界。这是三时间尺度不可混叠的纪律------进程级内容不得下沉为任务级，任务级内容不得下沉为步骤级，反之亦然。它与 Dijkstra（1968）结构化编程的"可理解性依赖结构规范性"同源。
契约拼接原则 ：层与层之间通过明确契约组合，而非隐式依赖。下层可以引用上层确立的不变式，但不可改变它；上层不感知下层的具体内容，只通过约定的槽位接收数据。这反映了时间尺度的嵌套方向------进程 ⊃ 任务 ⊃ 步骤，故依赖只能从长尺度流向短尺度，不可反向。它与契约式设计（Meyer, 1992）的前置条件、后置条件、不变式三段论同构。

3.3 规则与生成的结合：复杂度转移的再论证

分层本身只是结构，决定每一层"由谁产出"的是"规则与生成"的边界划定。本理念的主张是：稳定层用规则固化（模板/配置，零 LLM），易变层用 LLM 生成。

这一主张的合理性可通过"复杂度转移"论证（与《契约式脚本生成》一文同源）：在生成端增加约束（让 LLM 按模板填槽而非自由发挥）所引入的复杂度，远小于在使用端消除不确定性（解析、校验、缓存归因、复用匹配）所减少的复杂度。把可确定的逻辑下沉到规则模板，LLM 只负责真正需要语义判断的部分------这是一种"复杂度的集中偿还"：一次性在模板设计上付出，换得运行期无数次确定性操作。

定量地看：设一次 LLM 生成引入的约束成本为 c_constraint（模板设计、槽位定义、规则编写），而每次调用因不确定性消除节省的成本为 s_uncertainty（解析、校验、缓存归因）。当系统被调用 K 次后，净收益为 K · s_uncertainty − c_constraint。由于 s_uncertainty 在多轮、多任务系统中反复发生（这正是循环 × Agent 的场景），而 c_constraint 是一次性投入，K 稍大即净正。注意：这一净正收益的前提是 K 足够大，而 K 足够大的来源正是循环------若 K=1（单轮），净收益为负。这再次印证第一章的根因：规则与生成结合的经济性，同样依附于循环。

3.4 规则与生成的边界：可审计的守门人

规则与生成的边界不是模糊的"看情况"，而是由显式的判定函数划定。在本框架中，这个守门人是 rule_needs_replan：它用确定性条件（执行失败码、错误类别、任务范围字符串变化、连续无进展步数）判定何时让 LLM 介入。这一边界是工程化的关键------它使"何时用规则、何时用生成"成为可审计、可配置、可测试的决策，而非模型随机选择或开发者凭直觉。

边界的可审计性带来三个工程价值：其一，故障可定位------输出异常时可追溯是规则模板还是 LLM 生成的问题；其二，成本可预算------可统计模板命中率与兜底触发率，精确预测 LLM 调用次数；其三，边界可演化------当某类长尾频繁触发兜底，可将其吸纳为新的规则模板，使规则库随使用数据生长。这与神经-符号（Neuro-symbolic）混合系统的精神一致：用确定性规则锚定不变式，用神经生成处理长尾语义，二者各司其职。

四、分级模型：L0 / L1 / L2（三种时间尺度的投影）

本章把第一章的三时间尺度、第三章的三原则，落实为具体的 L0/L1/L2 分级模型。每一层都对应一种时间尺度，每一层的治理方式都由其稳定性决定。

4.1 L0 系统提示词：进程级常量

L0 是 Agent 的"宪法"------定义角色、全局约束、输出格式、安全规则。它对应进程生命周期 尺度，以固定文件形式存储（如 system.prompt.md），进程启动时加载一次，整个生命周期不变。

L0 的关键设计要点：

末尾死命令：在 L0 末尾放置"禁止开场白/结束语/解释过程，只输出最终结构化结果"等强约束，控制输出（呼应"轮次＞输出＞输入"中的第二杠杆）。
输出格式契约：明确 JSON/CSV 结构、截断规则、终止序列，使下游可用确定性代码零 Token 解析。
环境与权限声明：声明运行环境、可用工具集、权限边界，作为不变式被所有下层引用。
缓存资格：因 L0 完全不变且位于 prompt 最前端，稳定命中 API 自动前缀缓存，输入成本降至 0.1 倍。这是循环创造的缓存机会被 L0 捕获。
强区位利用：L0 位于 prompt 最前部，处于模型注意力的强区位，约束指令不易被后续长上下文稀释。

L0 的"不变"是相对进程生命周期而言的。跨版本迭代时，L0 可以演化------但每一次演化都是显式的版本变更，而非随任务随手修改。这种"受控的可变性"是 L0 作为不变式的纪律。

4.2 L1 任务级提示词：规则模板 + LLM 生成

L1 是任务的"任务书"------对应任务生命周期尺度，一次任务生成一次，结合用户输入与 L0 约束，给出结构化任务指引。L1 采用"规则模板 + SK 生成"的混合产出：

规则模板部分：任务分类槽位、目标槽位、约束槽位由规则根据用户输入的解析结果填充，不调用 LLM。
SK 生成部分：任务意图解析、目标细化调用 Semantic Kernel 生成一次（本项目即用 SK）。

L1 一旦生成就稳定下来，在同一任务的后续步骤中被复用，并作为 L0 之后的前缀获得缓存资格。这是 L1 设计的关键------它把"每步都要重新理解任务"的开销，收敛为"一次任务只理解一次"。L1 的生成成本被该任务的所有后续步骤摊销。这一摊销的前提是任务内有多个步骤------而多步骤的来源正是循环 × Agent（1.3 节）。若任务只有一步（单轮），L1 的生成成本无对象可摊销，分级反亏（反证一）。

L1 的模板部分与生成部分的边界，同样由规则判定：能从用户输入中确定性解析的字段（如任务类别、目标路径、参数列表）走模板填槽；需要语义理解的字段（如意图细化、隐含约束推断）走 SK 生成。这一划分使 L1 既有结构化的可复用骨架，又有语义化的灵活血肉。

4.3 L2 步骤级提示词：规则模板为主，LLM 兜底

L2 是步骤的"调度令"------对应步骤生命周期尺度，每步生成，基于上一步执行结果与规则匹配给出的提示词线索。L2 以规则模板为主：

首步：L2 = L1（无上一步结果，直接复用任务级指引）。
继续步 ：规则模板根据 next_prompt_hint 选模板、填槽位，默认零 LLM；仅当规则判定"需要语义重规划"（rule_needs_replan）时，才调用 SK 兜底生成。

rule_needs_replan 作为规则与生成边界的守门人（判定条件见 3.4 节），把生成限制在"模板无法覆盖"的长尾情形。

L2 的设计哲学是"默认不调 LLM"。在大多数顺利执行的步骤中，上一步结果足以通过模板转化为下一步指令------"翻译完成 12 个文件，需要继续处理测试目录"可直接模板化为"继续处理测试目录"的步骤指令，无需 LLM 重新规划。只有当执行偏离预期、模板无法给出合理下一步时，才让 LLM 介入重规划。这使得 L2 在常态下零 LLM 成本，仅在长尾时支付生成开销。L2 的存在本身是 Agent 的工具调用动态性的回应------正是因为工具结果不可预编码（1.3 节第二股力量），才需要一个独立的步骤级层级来承载这些动态内容，并把它们隔离在 prompt 尾部，不污染 L0/L1 前缀。

4.4 三级对照表

级别	名称	对应时间尺度	来源	频率	稳定性	成本	缓存策略	治理方式
L0	系统提示词	进程生命周期	规则（固定文件）	进程级常量	最高	0（命中前缀缓存，0.1× 输入）	固化，全量缓存	规则固化
L1	任务级提示词	任务生命周期	规则模板 + SK 生成	每任务 1 次	中	1 次 SK 调用/任务	生成后并入前缀缓存	规则模板 + 生成
L2	步骤级提示词	步骤生命周期	规则模板为主，SK 兜底	每步骤 1 次	最低	0（模板）或 1（兜底）	不缓存，增量生成	规则为主，生成兜底

新增的"对应时间尺度"列把每一层显式锚定到第一章的三时间尺度上，使分层不再是无根的结构，而是根因的直接投影。

4.5 成本数学模型：扁平 vs 分级

设扁平 prompt 总长度为 L，分级后 L0 = a、L1 = b、L2 = c（且 a + b + c ≈ L，信息总量相当），每轮输出为 O。输入单价为 1，输出单价为 3，缓存读取单价为 0.1。

方案 A（扁平 prompt）：动态上下文破坏前缀缓存，全量按原价计费。

复制代码

Cost_A = N × (L × 1 + 3 × O) = N × (L + 3O)

方案 B（分级 prompt）：L0 固化后缓存；L1 每任务生成一次（一次性成本），之后作为前缀缓存；L2 每步增量生成（不缓存）；每轮仍支付输出成本。

复制代码

Cost_B = (0.1a + 3b)                       ← 一次性 L1 生成（输入为 L0 缓存读 + 用户输入，输出为 L1）
       + N × (0.1a + 0.1b + c + 3O)        ← 每轮：L0/L1 缓存读 + L2 增量 + 输出

代入典型值 a = 2000, b = 1500, c = 500, O = 800（故 L = 4000）：

调用次数 N	方案 A（扁平）	方案 B（分级）	结论
1 次	6400 单位	7950 单位	A 更便宜（B 贵约 24%，因 L1 生成的一次性开销）
2 次	12800 单位	11200 单位	B 更便宜（B 节省约 12.5%）
5 次	32000 单位	20950 单位	B 碾压（B 节省约 34.5%）
10 次	64000 单位	37200 单位	B 节省约 42%

节省公式与阈值 ：令 S(N) = Cost_A − Cost_B，化简得：

复制代码

S(N) = N × [(a+b+c) − (0.1a + 0.1b + c)] − (0.1a + 3b)
     = N × 0.9(a+b) − (0.1a + 3b)

临界轮次 N* = (0.1a + 3b) / (0.9(a+b))。代入上例 N* ≈ 4700 / 3150 ≈ 1.49，即 N ≥ 2 时分级方案开始占优 ，且节省量随轮次线性增长，斜率为 0.9(a+b)。

用根因重读 N 阈值 *：N* 的存在是第一章根因在成本轴上的直接显形。N* ≈ 1.49 意味着分级的经济性完全依附于"N≥2"------而 N≥2 的来源正是循环。当循环不存在（N=1），S(N) < 0，分级净亏；当循环存在且 N 越大，S(N) 线性增长，分级净赚越多。这一阈值不是巧合的参数，而是根因的数学表达------它把"循环是分级的触发条件"从定性论断转化为定量边界。

敏感性分析：考察 N* 对参数的敏感度。L1 生成成本（3b）是 N* 的主要抬升项------L1 越长，分级方案回收投入所需的轮次越多。这给出一个工程启示：L1 应当"精炼"------只包含任务级必需的目标与约束，避免把可下沉到 L0 的稳定内容或可上浮到 L2 的动态内容塞入 L1。L1 越精炼，分级方案的优势门槛越低，对短任务也越友好。

这与《从"省着用"到"循环用"》一文第四节"N ≥ 2 文档化策略占优"的结论形成呼应：当任务注定多轮时，把稳定部分剥离缓存、把生成收敛到一次性的工程投入，从第二轮起即开始回收。差别在于，文档化策略剥离的是"长上下文数据"，而提示词分级剥离的是"稳定指令层"------两者同源，皆是按稳定性切分以换取缓存资格。

4.6 数据流走查：从首步到完成

以一个真实任务"把 src 模块所有中文注释翻译成英文"为例，走查分级 prompt 的端到端数据流。注意这一任务本身即是循环 × Agent：多文件翻译（循环）+ 自主工具调用（Agent）------根因在场，故分级承重。

复制代码

user_input = "把 src 模块所有中文注释翻译成英文"
│
▼ [provide_prompt] 首步
L0 = system.prompt.md（固定，命中缓存）              ← 0.1× 输入
L1 = SK 生成任务级提示词（1 次 LLM）                 ← 一次性 3× 输出
L2 = L1（首步复用）                                   ← 0
prompt = L0 + L1 + L2
│
▼ [cline_execute]
exec_result = { ok:true, text:"已翻译 12 个文件，需要继续处理测试目录..." }
│
▼ [rule_match]（零 LLM）
text contains "需要继续" → 命中 need_more
→ action=continue, next_prompt_hint="继续处理测试目录"
│
▼ [provide_prompt] 继续步
L0 = system.prompt.md（缓存）                         ← 0.1× 输入
L1 = 复用首步任务级提示词（缓存）                      ← 0.1× 输入
L2 = 规则模板填槽（hint → "继续处理测试目录"）         ← 默认零 LLM
prompt = L0 + L1 + L2
│
▼ [cline_execute] → exec_result = { ok:true, text:"测试目录已处理，完成" }
│
▼ [rule_match]（零 LLM）
text contains "完成" → 命中 done_marker → action=stop

全程 LLM 调用 3 次（1 首步规划 + 2 CLine 执行），rule_match 全程零 LLM，继续步的 L2 由模板填槽零 LLM。对比扁平 ReAct 在同等任务中常见的 7 次以上 LLM 调用（每轮重新生成完整 prompt 含历史），分级方案在轮次杠杆上即已显著占优。

与扁平 ReAct 的对照走查：同一任务若以扁平 ReAct 执行，每一轮的 prompt 形态为"系统指令 + 任务说明 + 第1轮观察 + 第1轮推理 + 第2轮观察 + ..."。到第 3 轮时，prompt 长度已从首轮的约 4000 token 膨胀至 8000 token 以上，且因历史轨迹夹在系统指令之后，前缀缓存从第 2 轮起即在第 3501 token 处分叉。扁平 ReAct 的根本问题，用根因语言说，是把 L2 的动态内容（每轮观察）物理插入 L0/L1 之后却未隔离------动态内容虽在尾部，但因每轮累积且未固化前缀，仍摧毁了缓存。分级方案则把 L0/L1 固化前缀、L2 增量尾部，使缓存资格最大化。

五、学术基础

本章从五个理论视角论证分级的合理性。值得注意的是，五条理论线索都隐含地假设了"重复"或"多层"的存在------它们的有效性皆依附于第一章的根因。

5.1 分层架构与关注点分离

提示词分层的理论起点是关注点分离与信息隐藏。Parnas（1972）在《On the Criteria to be Used in Decomposing Systems into Modules》中提出，模块划分的依据应是对"变化方向"的预期而非执行顺序------预期不变的部分应封装为独立模块，预期变化的部分应隔离以避免波及他者。提示词分级正是按"变化频率"对信息分层：L0 预期不变故固化，L1 预期任务级变化故模板化，L2 预期步骤级变化故增量生成。每一层都是一个"变化方向"的封装，层间通过槽位契约交互，符合 Parnas 的信息隐藏准则------上层只知下层"做什么"，不知"怎么做"。

Parnas 的"变化方向"在本文语境中即"时间尺度"------L0 对应进程级变化方向，L1 对应任务级变化方向，L2 对应步骤级变化方向。第一章已论证这三种变化方向由循环 × Agent 张开。因此 Parnas 原则的有效性，隐含地依赖三种变化方向的存在------若只有一种变化方向（单轮或固定流水线），Parnas 式分层便无对象可分。

Dijkstra（1968）的结构化编程主张程序的可理解性依赖于结构的规范性。当 prompt 遵循一套明确的分层组织规则时，阅读者（人或机器）可以快速定位角色定义、任务目标、步骤指令，而无需通读全文。可理解性从"全文理解"简化为"层级定位"------这对人工维护与自动化解析同样有益。

5.2 缓存局部性原理

为何固定前缀能命中缓存，可用局部性原理（Locality of Reference）解释。Denning（1968）提出工作集模型（Working Set Model），指出程序对信息的访问具有时间局部性与空间局部性------近期访问过的信息倾向于被再次访问。Denning（2005）在《The Locality Principle》中进一步将这一原理推广到从 CPU 缓存到 Web 缓存的各级存储层级。

API 提供商的前缀缓存正是这一原理在 LLM 服务层的落地：被反复访问的稳定前缀被保留在高速缓存中，命中时按折扣价计费。提示词分级把稳定信息物理上前置并固化，是在 prompt 层面主动构造"工作集"------使 L0（及生成后的 L1）成为高命中率的缓存友好前缀。扁平 prompt 之所以缓存失效，本质是它把动态信息塞入了前缀，破坏了工作集的稳定性，使局部性退化为随机访问。

局部性原理的有效性依附于循环。时间局部性的定义是"近期访问过的信息倾向于被再次访问"------这预设了"再次访问"，而"再次访问"的来源正是循环。单轮场景无"再次访问"，局部性原理无对象，缓存机制无意义。这是根因在缓存轴上的显形：循环创造重复访问，重复访问使局部性成立，局部性使前缀缓存命中，前缀缓存命中使分级经济性成立。链条任一环节断裂，分级即失去经济基础。

更形式化地，工作集 W(t, Δ) 定义为时间区间 $t-Δ, t$ 内被访问的信息集合。前缀缓存的有效性要求 W 在 Δ 窗口内对前缀部分保持稳定。分级框架通过把稳定层物理前置，使前缀部分的工作集近似恒定，从而最大化缓存命中率；扁平框架则因动态内容混入前缀，使工作集在每一轮都变化，缓存形同虚设。

5.3 提示工程文献

分级理念与既有提示工程文献既有承续也有区别：

Chain-of-Thought（Wei et al., 2022） 证明在 prompt 中引导模型逐步推理可显著提升复杂推理性能。CoT 关注的是"单次 prompt 内的推理结构"，而分级关注的是"跨轮次 prompt 的结构稳定性"------二者正交，L2 的步骤级模板完全可以内嵌 CoT 引导。
Few-shot Prompting（Brown et al., 2020, GPT-3） 证明在 prompt 中提供示例可触发上下文学习。示例的稳定性使其天然适合固化在 L0 或 L1，作为缓存友好前缀的一部分。Brown 等人的工作隐含了一个假设：示例与指令是可分离的------分级框架把这一假设显式化。
Prompt Chaining（Wu et al., 2022, AI Chains） 主张把大任务拆解为链式 prompt，每个 prompt 处理一个子任务。链式拆解与分级在"分解"精神上相通，但链式是横向的"任务拆分"，分级是纵向的"稳定性切分"------链式中的每一环内部仍可分级，二者是正交维度。值得注意的是，Prompt Chaining 本身就预设了"多步"------它是循环的一种形态，故其与分级的亲和性同样依附于根因。
Role-based Prompting（OpenAI Chat Completions 的 system/user/assistant 角色起源）是分层的早期雏形，把"系统指令"与"用户输入"分离，但仅是两层粗粒度划分，未进一步细化任务级与步骤级，也未挂钩缓存归因。
ReAct（Yao et al., 2022） 交替推理与行动，每轮携带完整历史，是扁平化的典型代表------其缓存失效与成本高昂正是分级框架要解决的问题。ReAct 同时是"循环 × Agent"的典型形态：它既是多轮迭代（循环），又是工具调用自主决策（Agent）。讽刺的是，ReAct 满足分级的根因，却未在 prompt 侧分级------这正是它成本高昂的根因性解释。Plan-then-Execute 模式部分缓解了这一问题，但其 prompt 侧仍未显式分层。

5.4 分布式认知

Hutchins（1995）的分布式认知理论（Cognition in the Wild）主张，智能系统应将认知负载卸载到环境的结构中，而非集中于中心处理单元。在 Agent 语境下，"环境结构"即提示词的组织方式。扁平 prompt 把所有认知负载压在 LLM 单次推理上；分级 prompt 则把"角色记忆""任务理解""步骤调度"分别卸载到 L0/L1/L2 三个结构层，使每一层的认知负担可控、可复用、可归因。这是把"单点认知"重构为"分层认知基础设施"。

分布式认知还提示一个更深的设计原则：认知负载的卸载应当"在生成时即按系统的认知结构预组织"，而非"卸载后再整理"。分级框架的 L0 固化、L1 模板化，正是这一原则的体现------稳定信息在系统初始化时即按 L0 结构组织，任务信息在生成时即按 L1 模板结构组织，系统无需事后从自由文本中逆向重构结构。这与《契约式脚本生成》一文中"卸载前已整理"的进化同构。

分布式认知的有效性依附于 Agent 的多步性。认知负载之所以需要卸载，是因为单次推理不足以完成全部认知------这预设了任务需要多步处理。单步 Agent 的认知负载本就可由单次推理承担，卸载无对象。这是根因在认知轴上的隐含依附。

5.5 规则与生成混合：神经-符号精神

规则与生成结合的范式，与神经-符号（Neuro-symbolic）AI 的精神同源。Garcez 与 Lamb（2020）在《Neurosymbolic AI: The 3rd Wave》中论述，将确定性符号规则与神经生成结合，可获得规则的可解释性、可验证性与神经模型的泛化能力。提示词分级中的"规则模板"承担符号规则的角色（确定、可验、零成本），"LLM 生成"承担神经生成的角色（灵活、泛化、有成本），二者的边界由 rule_needs_replan 这类显式判定函数划定（详见 3.4 节）。

5.6 理论综合

上述五条理论线索并非孤立，而是从不同视角汇聚到同一个设计主张，且都隐含地依附于第一章的根因：

理论	提供的支撑	在分级框架中的落点	对根因的依附
Parnas 1972 / Dijkstra 1968	按变化方向分层、职责单一	L0/L1/L2 的稳定性切分	依附：三变化方向由循环×Agent张开
Denning 1968/2005	工作集与局部性	L0/L1 固化前缀命中缓存	依附：局部性预设重复访问=循环
Hutchins 1995	认知负载卸载到结构	分层卸载 + 生成时预组织	依附：卸载预设多步=Agent
Wei 2022 / Brown 2020 / Wu 2022	提示工程的方法论遗产	分级与 CoT/Few-shot/Chaining 正交共存	依附：Chaining 预设多步
Garcez & Lamb 2020	规则与神经的结合边界	`rule_needs_replan` 的可审计守门	依附：规则摊销预设 K 大=循环

分层架构提供"为什么分"，局部性原理提供"为什么缓存能命中"，分布式认知提供"为什么卸载有效"，提示工程文献提供"与既有方法如何共存"，神经-符号提供"规则与生成的边界如何划定"。五者合起来，构成提示词分级的完整理论地基------而这一地基之所以稳固，是因为它们共同站立在"循环 × Agent"这一根因之上。

5.7 与 Plan-then-Execute 及计划缓存的学术谱系

提示词分级还与规划-执行分离及计划缓存的学术谱系深度关联。Plan-then-Execute 模式将战略规划与战术执行显式解耦：Planner 由推理能力强的模型承担，Executor 按计划逐步执行。研究表明，角色分解的 Agent 团队持续占据成本-准确率的帕累托前沿，异构团队相比同构团队准确率可提升高达 44%，或以低至 1/12 的每任务成本达到同等性能。Agentic Plan Caching（APC）进一步将计划缓存引入测试时记忆，实现成本与延迟的显著降低------但收益高度依赖缓存命中率，未命中时还需支付检索与比对开销。

本框架与这一谱系的关系是"prompt 侧的对应物"：Plan-then-Execute 解决的是"调用结构的解耦"（N 次复杂推理压缩为 1 次规划 + M 次轻量执行），提示词分级解决的是"prompt 结构的解耦"（扁平 prompt 压缩为 L0 缓存 + L1 一次性 + L2 增量）。L1 对应 Plan，L2 对应 Execute 的逐步调度，L0 则是 Plan 与 Execute 共享的不变式。APC 的"命中率依赖"教训同样适用于分级：L1 的缓存资格依赖其生成后的稳定性，若 L1 在任务内反复重生成（违反 L1 设计纪律），则缓存收益归零，分级退化为扁平------这与 APC 未命中时净亏的情形同构。

学术谱系	解决的问题	在分级框架中的对应
Plan-then-Execute	调用结构解耦	L1=规划，L2=执行调度
Agentic Plan Caching	计划复用	L1 生成后缓存复用，命中率即收益关键
CodeMem / CodeAct	逻辑从上下文转移到确定性代码	L0 规则固化，将"模糊推理"转"确定操作"

这一谱系印证了分级的必要性：当规划、执行、缓存都被显式化后，prompt 本身若仍保持扁平，则成为系统中最后一个未被工程化的环节。分级正是补齐这一环的 prompt 侧工程化。而 Plan-then-Execute 与 APC 本身都预设了"多步规划 + 多步执行"------它们的有效性同样依附于循环 × Agent 根因。

六、与现有分层方案的对比

提示词的"分层"在工业界其实早已隐式存在，但多停留在粗粒度、未与成本归因挂钩、更未识别"循环 × Agent"这一根因。本节对照分析主流方案，阐明本框架的定位。

6.1 OpenAI Chat Completions 的角色分层

OpenAI Chat Completions API 原生支持 system / user / assistant 三种角色消息。system 消息固化角色与约束，是分层的最早雏形。其贡献在于把"系统指令"与"用户输入"物理分离，使 system 部分具备缓存资格。其不足在于：粒度仅两层（系统 vs 非系统），任务级与步骤级未区分；缓存归因未被显式建模；未识别根因------它把分层当作 API 的便利特性，而非循环 × Agent 场景下的承重结构，故未进一步细化。

6.2 LangChain 的模板槽位机制

LangChain 提供 PromptTemplate、FewShotPromptTemplate、ChatPromptTemplate，通过 {``{var}} 槽位填充实现模板化。其贡献在于把"模板"与"变量"分离。其不足在于：模板是"一次性渲染"的，渲染后即拼成扁平 prompt，仍存在缓存失效问题；槽位机制不区分任务级与步骤级；未识别根因------模板化是通用机制，不锚定三时间尺度，故在单轮与多轮场景一视同仁，无法在多轮时自动升级为承重结构。

6.3 Microsoft Semantic Kernel

Semantic Kernel（SK）提供 prompt template 与 system prompt 的组合机制，并把 prompt 作为可注册的函数（Semantic Function）纳入编排。本项目即采用 SK 作为生成后端。SK 的贡献在于把 prompt 提升为"一等公民"------可注册、可编排、可组合。其不足在于：SK 的模板仍是单层的，未显式划分 L0/L1/L2 的稳定性层级；模板渲染后同样面临缓存归因缺失。本框架可视为对 SK 模板机制的"分层增强"：在 SK 生成能力之上，叠加分级与缓存归因，使 SK 的 Semantic Function 自然落入 L1/L2 的生成槽位。

6.4 Anthropic Claude 的 system prompt 与 Constitutional AI

Anthropic Claude 支持独立的 system prompt，并通过 Constitutional AI（Bai et al., 2022）把"宪法"规则注入模型对齐过程。其贡献在于把安全规则与任务指令分离，使安全约束作为不变式始终生效------这与 L0 的"宪法"定位高度一致。其不足在于：Constitutional AI 作用于训练时对齐而非运行时分层，运行时的 prompt 仍是系统/用户两层粗粒度；安全规则之外的任务级、步骤级未进一步细化。

6.5 LlamaIndex 的 prompt templates

LlamaIndex 提供结构化 prompt templates，常与检索增强生成（RAG）结合。其贡献在于把"检索到的上下文"与"指令模板"分离。其不足在于：检索上下文的动态性使其不命中缓存，而模板与检索内容的拼接顺序若不当，会破坏前缀稳定性------这恰是本框架要解决的"前缀缓存归因"问题。分级框架会建议把检索上下文置于 L2 末尾，使 L0/L1 的稳定前缀不被检索内容破坏。

6.6 Prompt Chaining 与 ReAct

Prompt Chaining（Wu et al., 2022）把大任务拆成链式 prompt，ReAct（Yao et al., 2022）在每轮交替推理与行动。二者的贡献在于把"任务分解"与"执行循环"显式化。其不足在于：链式每一环、ReAct 每一轮的 prompt 仍可被扁平化构造，未区分稳定指令与动态上下文；ReAct 尤其因每轮携带完整历史而缓存失效、成本高昂。ReAct 是"循环 × Agent 根因在场却未分级"的典型------它满足根因（多轮 + 自主工具调用），却在 prompt 侧保持扁平，故其成本高昂有根因性解释。 分级框架与 Chaining 是正交的------链式每一环内部都可采用 L0/L1/L2 分级，而分级框架的 L2 步骤级提示词本身就是对 ReAct 循环中"每轮重新生成完整 prompt"问题的直接回应。

6.7 共性、不足与本框架的定位

方案	分层维度	粒度	规则/生成边界	缓存归因	根因识别
OpenAI 角色	system / user	两层	无显式边界	隐式	否
LangChain 模板	模板 / 变量	单层渲染	无判定机制	缺失	否
Semantic Kernel	模板 / system	单层	无判定机制	缺失	否
Claude / Constitutional	system / 训练时对齐	两层 + 训练	训练时规则	隐式	否
LlamaIndex	模板 / 检索上下文	单层渲染	无判定机制	易破坏	否
Prompt Chaining / ReAct	横向任务拆分	每环单层	无判定机制	缺失	否（ReAct 满足根因却未分级）
本框架（L0/L1/L2）	稳定性纵向切分	多级	`rule_needs_replan` 显式判定	显式归因	是（循环×Agent）

共性：上述方案都隐含"分层"直觉------都意识到有些信息该固定、有些该变化。不足：它们都未把分层显式化为"稳定性递减的纵向切分"，也未把"规则 vs 生成"作为显式边界，更未把分层与缓存归因挂钩，最关键的是都未识别"循环 × Agent"这一根因 ------故它们的分层是"通用便利"而非"承重结构"，在根因不在场的场景仍强行分层（冗余），在根因在场的场景又分层不足（如 ReAct）。本框架的贡献 正在于四点：其一，识别根因------分级由循环 × Agent 触发，是结构性必然而非普遍最佳实践；其二，把隐含的分层直觉显式化为 L0/L1/L2 的稳定性层级，锚定三时间尺度；其三，用 rule_needs_replan 划定规则与生成的可审计边界；其四，使每一层的成本与缓存资格可被归因。四者合一，把"写 prompt"升级为"编排 prompt 架构"。

需强调的是，本框架并非取代上述方案，而是为它们提供统一的"分层骨架"。OpenAI 的 system 角色、LangChain 的模板、SK 的 Semantic Function、Claude 的宪法，都可被吸纳为 L0 或 L1 的具体实现；本框架提供的是"它们应当如何被组织、缓存、归因，以及何时（循环 × Agent 在场）才值得如此组织"的元结构。

七、工程落地

7.1 模板与槽位设计

L1/L2 的模板采用 {``{var}} 槽位填充机制，模板文本与填充规则外部化到配置文件（如 templates.json），与代码解耦。一次提示词生成的伪代码：

复制代码

provide_prompt(user_input, exec_result?, next_prompt_hint?):
    L0 = load("Config/prompts/system.prompt.md")        # 规则，固定，命中缓存
    if 首步 (exec_result == null):
        L1 = SK.generate_task_prompt(user_input, L0)     # 规则模板 + SK 生成（1 次 LLM/任务）
        L2 = L1                                           # 首步无上一步结果，复用 L1
    else:
        L2 = rule_template.fill(exec_result, next_prompt_hint)  # 规则模板填槽，默认零 LLM
        if rule_needs_replan(exec_result):                # 规则判定
            L2 = SK.generate_step_prompt(exec_result, hint, L0)  # SK 兜底生成
    return L0 + L1 + L2

rule_needs_replan 的判定条件示例：执行返回非零退出码、出现未注册的错误码、任务范围字符串变化、连续两步无进展。这些条件是确定性的、可配置的、可审计的------它们是规则与生成边界的"守门人"。模板库可随使用数据演化：当某类长尾频繁触发兜底，可将其吸纳为新的规则模板，使规则库随使用数据生长。

7.2 缓存策略表

层	时间尺度	内容	是否固化	是否缓存	生成方式	单价
L0	进程级	角色/约束/格式/安全	是	是（前缀缓存）	规则文件	0.1× 输入
L1	任务级	任务目标/意图/约束	生成后固化	是（并入前缀）	模板 + SK（每任务 1 次）	首次 1× 输入 + 3× 输出；后续 0.1× 输入
L2	步骤级	步骤指令/上步反馈	否	否	模板为主，SK 兜底	1× 输入（模板时仅 c）
输出	---	执行结果	---	---	LLM 执行端	3× 输出

7.3 与"规划-执行分离"的关系

如 5.7 节所述，提示词分级与"规划-执行分离"（Plan-then-Execute）同构：L1=规划，L2=执行调度，L0=共享不变式。这一对应使分级框架可直接嵌入既有 Plan-then-Execute 架构，作为其 prompt 侧的落地形态。更进一步，L1 产出的任务级指引本身就是一份"文档化 Plan"------这与《从"省着用"到"循环用"》一文中"规划即文档"的范式一致：L1 的生成本就是本职工作，无需额外生成摘要。

7.4 成本控制：L0 末尾死命令

输出 Token 单价为输入的 3 倍，必须强力管控。L0 末尾放置死命令------"禁止开场白/结束语/解释过程，只输出最终结构化结果"------是分级框架对输出控制的贡献。把死命令固化在 L0 而非每步重申，有两个好处：其一，固化部分命中缓存，控制成本几乎为零；其二，死命令位于所有动态内容之前（L0 在最前），不会被长上下文稀释，始终处于模型注意力的强区位。这呼应了"控制输出"作为成本优化第二杠杆的工程纪律。

7.5 错误降级

分级框架的鲁棒性来自规则与生成的双重保险。当 LLM 生成失败时，系统按确定性路径降级：

L1 生成失败：重试一次（temperature=0）；仍失败则退化为纯模板填槽（任务级指引用通用模板兜底），或降级到既有的全生成路径。
L2 兜底生成失败 ：退化为纯规则模板，按 next_prompt_hint 给出保守的下一步指令。
规则集损坏 ：使用内置默认规则（default → stop），告警但不崩溃。

降级链确保"生成"始终是规则的补充而非依赖------规则可独立支撑系统运行，生成只在可用时锦上添花。这与《契约式脚本生成》一文中"约束的本质是解放"同构：规则约束不是为了限制生成，而是为了在生成失效时仍有确定性的兜底。

7.6 可观测性：缓存归因与模板命中率

分级框架的工程化离不开可观测性。两个核心指标必须被持续监控：

前缀缓存命中率：按层统计 L0、L1 的缓存命中 token 数与未命中 token 数。命中率下降是 prompt 漂移的早期信号------可能某次修改无意中改变了 L0 内容，或 L1 生成不稳定导致前缀分叉。
模板命中率与兜底触发率 ：统计 L2 由模板填槽的比例与触发 rule_needs_replan 兜底生成的比例。兜底触发率高意味着模板库覆盖不足，应将高频长尾吸纳为新模板；触发率过低则可能意味着规则过于激进，应复查 rule_needs_replan 条件。

这两个指标把"提示词质量"从主观感受转化为可度量的工程指标，是分级框架"可归因"原则的直接落地。

7.7 测试与验证策略

分级框架的可测试性来自层间的契约边界------每一层都可被独立测试，无需依赖 LLM 的不确定性。测试矩阵按层组织：

层	测试要点	是否消耗 AI	验证手段
L0	进程级常量、内容一致性	否	加载快照比对，确认跨进程加载一致
L0	缓存资格稳定	否	前缀哈希稳定，无随机化字段混入
L1	模板填槽正确	否	{``{var}} 替换、规则选模板分支覆盖
L1	SK 生成调用次数	mock	首步仅调 SK 一次，继续步不调
L2	模板填槽零 LLM	mock	继续步默认不触发 SK
L2	`rule_needs_replan` 边界	否	各触发条件的真值表覆盖
端到端	首步→继续→完成流转	mock	节点路由正确、`rule_match` 控制循环
降级	L1 失败退纯模板	mock	SK 抛错后走模板兜底，不崩溃
降级	规则集损坏用默认	否	损坏配置加载后 `default → stop`

关键验收标准有四：其一，循环控制零 LLM（rule_match 全程不调 LLM）；其二，L0 缓存命中（系统提示词进程级固定）；其三，模板优先（继续步默认零 LLM，仅规则判定需重规划时调 SK）；其四，无无限循环（max_steps 守卫与规则 default → stop 双保险）。这四条标准使分级框架的工程行为可被自动化验证，而非依赖人工目测 prompt 输出------这是"提示词系统工程"区别于"提示词技艺"的标志。

7.8 反向应用：根因不在场时显式跳过分级

第一章的根因不仅有建构意义，还有判别意义------它告诉工程师生么时候不该分级。当系统不满足"循环 × Agent"时（单轮 QA、固定批处理流水线、无工具调用的单步 Agent），分级是过度设计：N=1 时分级反亏 24%，固定流水线单模板即足。此时应显式跳过分级，采用扁平 prompt 或单模板，避免 L1 生成的一次性开销与三层结构的维护负担。这一"反向应用"是根因识别的工程红利------它不仅告诉你何时分级，也告诉你何时不分级，避免把承重结构误用到非承重场景。这与第六章对现有方案的批评形成闭环：现有方案因未识别根因，在根因不在场时仍强行分层（冗余）；本框架因识别根因，在根因不在场时显式跳过（精简）。

八、更深层的意义

8.1 从"写 prompt"到"编排 prompt 架构"

提示词分级标志着一种范式转移：prompt 不再是"一段被一次性写就的文本"，而是"一套被编排的架构"。写 prompt 的关注点是措辞与示例；编排 prompt 架构的关注点是层级划分、稳定性切分、缓存归因、规则与生成的边界判定。前者是技艺，后者是工程。当 Agent 从单次对话走向规模化部署，前者不足以支撑系统演化，后者才是可持续的路径。这一转移与软件工程从"写代码"到"设计架构"的成熟过程同构------提示词工程正在经历自己的"软件工程化"时刻。

8.2 分层是 Agent 工程化的前提

工程化的本质是可度量、可复用、可归因。提示词扁平化使这三者皆失：成本无法归因、复用无从着手、度量缺乏锚点。分层正是恢复这三者的前提：

可归因：L0/L1/L2 各自的成本可独立计算，缓存命中率、生成次数、模板命中率皆可量化。
可复用：L0 跨任务复用、L1 跨步骤复用、模板跨任务复用，复用粒度明确。
可度量：每一层的命中率、失败率、降级率可分别统计，为优化提供方向。

没有分层，就没有 Agent 的系统工程；正如没有模块化，就没有软件工程。而分层之所以是"前提"，正是因为循环 × Agent 根因使分层成为承重结构------在根因在场的生产场景，不分层即不可工程化。

8.3 与契约式脚本生成的呼应

提示词分级与《契约式脚本生成》一文形成深层呼应。契约式设计的三段论------不变式、前置条件、后置条件------可自然映射到分级框架：L0 是不变式（整个任务执行过程中保持的属性，如角色、安全规则）；L1 是前置条件（任务开始前必须确立的目标与约束）；L2 是后置条件可类比的步骤反馈（每步执行后据结果调整的指令）。分层是契约的物理载体------没有分层，契约就只能散落在文本各处，无法被系统读取与校验。两篇文章共同指向同一个主张：把隐式约定显式化为可机器读取的结构，是从"认知密集型"到"确定性操作"转变的统一路径。

8.4 常见反模式

为帮助识别实践中的偏离，列举四种分级反模式：

L0 膨胀：把任务级甚至步骤级内容塞进 L0，使"宪法"变成"百科全书"。后果是 L0 频繁变更，缓存资格丧失。判据：L0 中出现具体任务名、具体参数、具体步骤。
L1 不复用：每步重新生成 L1，使任务级指引沦为步骤级。后果是 L1 的生成成本无法摊销，分级退化为扁平。判据：L1 生成次数大于 1 且任务未变更。
L2 全生成：放弃模板，每步都调 LLM 生成 L2。后果是 L2 的零 LLM 优势丧失，成本线性增长。判据：L2 兜底触发率接近 100%。
边界模糊 ：rule_needs_replan 条件随意或缺失，生成与规则的切换不可预测。后果是故障不可定位、成本不可预算。判据：无法回答"这次 LLM 调用为何被触发"。

还有一种根因性反模式：根因不在场却强行分级。在单轮 QA 或固定流水线场景套用 L0/L1/L2，L1 生成开销无法摊销，三层结构成为维护负担。判据：N=1 或无自主工具调用却维持三级结构。识别反模式的能力，本身就是工程成熟度的标志。

8.5 分级与"省着用/循环用"的统一

提示词分级与《从"省着用"到"循环用"》一文提出的成本优化框架构成统一体系。该文将策略分为正交两类：对一次性任务"省着用"（压缩/截断），对高频任务"循环用"（缓存/复用）。提示词分级恰好是这两类策略在 prompt 侧的统一载体：

L0 固化是"循环用"的极致形态：稳定指令跨任务、跨进程复用，命中前缀缓存，边际成本趋近于零。
L1 生成后缓存是"循环用"的任务级形态：一次任务内复用，跨步骤摊销生成成本。
L2 模板填槽是"省着用"的步骤级形态：增量生成、零 LLM，压缩单次调用的输入与轮次。
L2 兜底生成是"省着用"对长尾的兜底：模板无法覆盖时才支付生成成本，把生成限制在必要环节。

策略（来自"省着用/循环用"）	在分级框架中的落点	适用任务分布
循环用（缓存/复用）	L0 跨任务复用、L1 任务内复用	高频标准化
省着用（压缩/截断）	L2 模板填槽、增量生成	一次性、长尾
规划即文档	L1 即文档化 Plan	多轮任务
最大重试阈值	`max_steps` 守卫 + 规则 `default → stop`	所有任务

这一统一并非偶然------"省着用"与"循环用"的划分依据是任务分布（高频 vs 长尾），而分级的依据是信息稳定性（稳定 vs 易变）；二者在 prompt 侧汇合，是因为"稳定信息恰好是高频复用的对象，易变信息恰好是一次性处理的对象"。稳定性切分与任务分布切分在 prompt 层面同构，使分级框架成为"省着用/循环用"策略的天然物理载体。而"循环用"的适用前提是循环存在------这再次回到第一章的根因。

九、结语

提示词分级的核心主张可以简洁表述为：分级由循环与 Agent 共同触发，是二者的结构性必然投影。

Agent 按定义即"面向目标的多步工具调用循环"，这一本质张开了进程-任务-步骤三种嵌套时间尺度，L0/L1/L2 正是这三种尺度在 prompt 结构上的必然投影。单轮无循环则无缓存可命中（N=1，分级反亏）；循环无自主性则单模板即足（固定流水线，三级冗余）；Agent 无循环则无跨轮累积（单步，缓存破坏未显形）------唯有循环 × Agent 交汇，分级才从"锦上添花"变为"承重结构"。

扁平 prompt 的四重困境（缓存失效/复用趋零/维护高企/输出失控）本质是根因在场而未识别时的表征：系统已处于循环 × Agent 场景，却仍把三种时间尺度的内容物理粘合，使稳定部分被动态部分拖累。解法是把提示词视为分层架构，按稳定性递减划分为 L0/L1/L2，用规则固化稳定层、用生成处理易变层，并以 rule_needs_replan 划定可审计的边界。三个维度印证其合理性：学术层面，分层架构与关注点分离（Parnas 1972、Dijkstra 1968）、缓存局部性（Denning 1968/2005）、分布式认知（Hutchins 1995）、提示工程文献（Wei 2022、Brown 2020、Wu 2022）与神经-符号混合（Garcez & Lamb 2020）五条线索皆隐含依附于这一根因；工程层面，成本数学模型表明 N≥2 时分级方案即占优，节省量随轮次线性增长（斜率 0.9(a+b)），而 N≥2 的来源正是循环；战略层面，它把"写 prompt"升级为"编排 prompt 架构"，使成本可归因、模板可复用、层贡献可度量。

只有识别循环与 Agent 这一根因，才知道何时分级（根因在场，承重）、何时不分级（根因不在场，精简）。只有分级，才能缓存；只有缓存，才能复用；只有复用，才能归因；只有归因，才能优化。提示词分级不是写作技巧的精进，而是 Agent 走向工程化的结构性前提------这是从"提示词工程"到"提示词系统工程"的范式跃迁，而跃迁的起点，是认清分级之所以必要的那个根因。

关键决策速查表

场景	推荐策略	核心动作
判别：是否多轮？是否自主工具调用？	二者皆是 → 必须分级；任一为否 → 可不分级	根因判别准则是分级的第一道决策（1.5 节）
系统角色/安全/格式约束	L0 固化	规则文件存储，命中前缀缓存（0.1× 输入），末尾死命令控制输出
任务目标/意图解析	L1 模板 + SK 生成	每任务 1 次 LLM，生成后并入前缀缓存
步骤指令/上步反馈	L2 规则模板为主	默认零 LLM，`rule_needs_replan` 命中时 SK 兜底
单次任务（N = 1，无循环）	显式跳过分级	根因不在场，分级反亏 24%，扁平或单模板更优（7.8 节）
固定流水线（循环但无 Agent）	单模板层	根因不全，三级冗余，一层模板即足（1.2 反证二）
多轮任务（N ≥ 2，循环 × Agent）	必须分级	节省量随轮次线性增长，斜率 0.9(a+b)
L1 精炼度	只含任务级必需内容	L1 越精炼，分级优势门槛 N* 越低，对短任务越友好
LLM 生成失败	规则降级	L1 退纯模板，L2 退规则模板，规则集损坏用默认规则
输出失控	L0 末尾死命令	死命令固化在前缀强区位，零成本反复生效
跨任务复用	L0 + 模板库	L0 进程级复用，模板跨任务复用，生成只覆盖长尾
规则 vs 生成边界	`rule_needs_replan` 判定	确定性条件守门，使"何时用 LLM"可审计
缓存归因	按层统计命中率	L0/L1 命中率、L2 模板命中率分别量化
L0 膨胀反模式	任务/步骤内容下沉	L0 只放进程级不变式，出现具体参数即下沉
长尾频繁兜底	吸纳为新模板	高频兜底信号驱动模板库演化