@ai-agent-forge/plugin-steering-guard 0.0.0-stage → 0.88.16

package/README.md

@@ -1,3 +1,27 @@
-# Temporary Holding Version
+# @agent-forge/plugin-steering-guard
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Agent Forge 中途引导落账提醒插件（`docs/design/中途引导与任务状态联动设计.md` §4.1 路线 A、§7 S5，第二层强化）：检测到 run 进行中到达的用户引导时，向下一次模型请求的视图尾部注入一条 `display:false` 的提醒，提示模型按六类分类引导并按跨面落账顺序在本回合内落账。第一层常驻纪律由 goal 插件的 `TASK_TOOLS_GUIDE` 承载，本插件只做决策点提醒，不重复常驻文本。
+
+bundled 分发，宿主通过 manifest 加载；禁用面为会话装配的 `disabledPluginIds`（`agent-forge.plugin.steering-guard`）。提醒只在请求视图内生存（不写 `context.messages`、不进 `newMessages`，不持久化），对用户不可见。
+
+## 行为契约
+
+- 探测：宿主在 `_runInputHandlers` 内联 await `beforeInput` loop 钩子，先于 prompt 路径的 run 激活、也先于 steer/followUp 入队返回。钩子时刻读 `SessionAPI.isIdle()` 是确定性的：idle ⇒ 该输入开新 run（清零 pending），busy ⇒ 运行中（含压缩中）到达的引导（pending 加一）。
+- 注入：`transformContext` 链路在 pending > 0 且任务面在场时，向请求视图尾部追加一条提醒并消费一个计数（同一引导只提醒一次；run 内连发多条引导各提醒一次）。
+- 生效边界：`SessionAPI.getActiveTools` 与任务面工具（`goal_set`/`plan_set`/`todo_update`/`workflow_set`/`workflow_advance`）无交集时不注入（计数保留，下一请求再判）；`getActiveTools` 不可用时视为在场（宁可多提醒）；宿主无 `SessionAPI` 时插件保持惰性（一切输入按 run-start 处理，零提醒）。
+- 压缩边界：不维护消息计数基线，不存在压缩致基线失真的问题；压缩期间 `isIdle()` 为 false，压缩窗口内到达的引导照常注入（确定性测试钉住）。
+
+## 探测结论（实施前源码验证）
+
+- `input.received@1` 不流经 `CapabilityAPI.subscribe` 可见的总线：该事件经 `dispatchInputReceivedLifecycle` 只派发到 capability runtime 的 lifecycle 目录通道（`dispatchLifecycleImpl` 只读 `lifecycleRegistrations`），而 `subscribe`/`publish` 是独立的插件间总线（宿主从不向其发布宿主事件，`plan.changed` 等均由插件自身 `api.publish`）。
+- lifecycle 通道的派发是 fire-and-forget 异步（宿主 `void dispatch...`），相对 run 激活（`runDefaultLoop` 置 `_isAgentRunActive`）无顺序保证——"新 prompt 开新 run"路径在派发时刻读 `isIdle()` 是竞态，无法确定性满足"首请求/新回合首请求不提醒"。
+- 故探测事件选 `beforeInput` loop 钩子（与 `transformContext` 同属 loop-hook 公共通道），状态机与决策矩阵全为纯函数（`src/detector.ts`）。
+
+## 测试
+
+`npm test`（确定性，零真实 AI/网络）：
+
+- `test/detector.test.ts`：决策矩阵逐格（首请求/新回合/steering/去重/重放/连发/压缩窗口/任务面缺席/默认在场）。
+- `test/entry.test.ts`：公共面接线（钩子注册、信号映射、注入与去重、门控保留计数、dispose）。
+- `test/manifests.test.ts`：三份清单（plugin.json / agent-forge.json / package.json）一致性。
+- `test/registration.test.ts`：manifest 通道真实装载（需先构建 dist：`npm run build`）。

package/agent-forge.json

@@ -0,0 +1,19 @@
+{
+	"packageFormatVersion": 1,
+	"id": "agent-forge.plugin.steering-guard",
+	"pluginVersion": "0.88.16",
+	"apiVersion": "1",
+	"minHostVersion": "0.88.0",
+	"platform": {
+		"os": [
+			"windows",
+			"macos",
+			"linux"
+		],
+		"runtime": [
+			{
+				"name": "node"
+			}
+		]
+	}
+}

package/dist/detector.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 中途引导落账提醒的探测核心（设计 `docs/design/中途引导与任务状态联动设计.md`
+ * §4.1 路线 A、§7 S5；第二层强化，第一层常驻纪律在 goal 插件的
+ * TASK_TOOLS_GUIDE）。全部逻辑为纯函数：输入是输入到达信号 + 既有状态，输出是
+ * 是否注入与新状态；entry.ts 只做公共面接线与闭包状态持有。
+ *
+ * 探测选型（实施前源码验证，见 README "探测结论"）：
+ * - `input.received@1` 不流经 `CapabilityAPI.subscribe` 可见的插件间事件总线
+ *   （宿主从不向该总线发布宿主事件；它只走 lifecycle 目录通道），且其派发为
+ *   fire-and-forget 异步（`agent-session.ts` 的 `void dispatchInputReceived...`），
+ *   相对 run 激活（`runDefaultLoop` 置 `_isAgentRunActive`）无顺序保证——在派发
+ *   时刻读 `isIdle()` 对"新 prompt 开新 run"路径是竞态，无法确定性地满足
+ *   "首请求/新回合首请求不提醒"。
+ * - 因此探测事件取 `beforeInput` loop 钩子：宿主在 `_runInputHandlers` 内联
+ *   await 该链，先于 prompt() 的 isStreaming 分支与 run 激活、也先于 steer/
+ *   followUp 入队返回。钩子调用时刻读 `isIdle()` 因此是确定性的：
+ *   idle === 该输入开新 run（"run-start"），busy === 该输入是运行中到达的
+ *   steering/followUp（"steer"）。这正是本插件需要的"run 内新增 user 消息 vs
+ *   新 run 首条"判别器，且与 transformContext 同属 loop-hook 公共通道。
+ *
+ * 压缩边界：本路线不维护消息计数基线，不存在"压缩后基线失真"问题。压缩期间
+ * `isIdle()` 为 false（isIdle = !runActive && !compacting），压缩窗口内到达的
+ * 引导照常置 pending，压缩后的下一请求照常注入——"压缩不丢失引导提醒"由构造
+ * 保证（测试矩阵钉住）。
+ */
+/** 注入消息的 customType（标记来源；display:false，仅存在于该次请求视图）。 */
+export declare const STEERING_GUARD_CUSTOM_TYPE = "steering_guard";
+/**
+ * 任务面工具名（生效边界，设计 §3.7）：这些工具全部不在场（readonly 会话或
+ * 用户禁用任务面插件）时，引导落账无承载面，不注入提醒。
+ */
+export declare const TASK_FACE_TOOL_NAMES: readonly string[];
+/** 注入到请求视图尾部的提醒文本（英文，≤60 词，契约固定措辞）。 */
+export declare const STEERING_GUARD_REMINDER_TEXT = "[steering-guard] Mid-run user input arrived. Apply the steering discipline: classify it (background/add/modify/cancel/pivot/fork), settle required state changes this turn via the task tools \u2014 workflow-level consequences first, then plan/goal, todos last; touch only affected records; a cancelled todo needs the user's line as evidence.";
+/**
+ * 结构化镜像宿主 `core/messages.ts` 的 CustomMessage（同 loop-guard 先例：内核
+ * 类型不跨入插件面，字段漂移由宿主 e2e 拦截）。本插件只生产 display:false 的
+ * 模型面提醒，不写 context.messages、不进 newMessages，故不持久化。
+ */
+export interface SteeringGuardReminderMessage {
+    role: "custom";
+    customType: string;
+    content: string;
+    display: boolean;
+    timestamp: number;
+}
+/** display:false 的引导落账提醒消息（transformContext 注入用，同请求视图内生存）。 */
+export declare function createSteeringGuardReminder(): SteeringGuardReminderMessage;
+/**
+ * 输入到达信号："run-start" = 该输入开启新 run（isIdle 为 true 时收到）；
+ * "steer" = 该输入在 run（或压缩）进行中到达。
+ */
+export type SteeringInputSignal = "run-start" | "steer";
+/**
+ * 吸收一个输入到达信号，返回新的 pending 计数。
+ *
+ * - "run-start"：新 run 的首条输入就是本轮 prompt 本身，不是中途引导——清零
+ *   pending（同时丢弃上一 run 中止后残留的未消费计数，防止跨 run 泄漏提醒）。
+ * - "steer"：运行中到达一条引导，pending 加一。计数而非布尔：同一 run 内连发
+ *   两条引导各提醒一次（每次请求消费一条；两条在同一次请求前到达时，分两次
+ *   请求各注入一次）。
+ */
+export declare function absorbSteeringInputSignal(pendingSteerCount: number, signal: SteeringInputSignal): number;
+/** 一次注入判定的输出：是否注入 + 消费后的新 pending 计数。 */
+export interface SteeringReminderDecision {
+    readonly inject: boolean;
+    readonly pendingSteerCount: number;
+}
+/**
+ * 注入判定：pending > 0 且任务面在场时注入一条提醒并消费一个计数；任务面缺席
+ * 时保留计数（本请求不注入，下一请求再判——工具面可能在 run 内动态恢复）；
+ * pending 为 0 时维持去重（同一引导只提醒一次、重放不重复提醒）。
+ */
+export declare function decideSteeringReminder(pendingSteerCount: number, taskFacePresent: boolean): SteeringReminderDecision;
+/**
+ * 任务面在场判定（生效边界，设计 §3.7）：`getActiveTools` 不可用（SessionAPI
+ * 可选面缺席）时视为在场——宁可多提醒；在场列表与任务面工具无交集时不注入。
+ */
+export declare function isTaskFacePresent(activeTools: readonly string[] | undefined): boolean;
+//# sourceMappingURL=detector.d.ts.map

package/dist/detector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.d.ts","sourceRoot":"","sources":["../src/detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,uGAAuD;AACvD,eAAO,MAAM,0BAA0B,mBAAmB,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,SAAS,MAAM,EAMjD,CAAC;AAEF,iGAAuC;AACvC,eAAO,MAAM,4BAA4B,yVACyS,CAAC;AAEnV;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC5C,IAAI,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CAClB;AAED,8GAA8D;AAC9D,wBAAgB,2BAA2B,IAAI,4BAA4B,CAQ1E;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,OAAO,CAAC;AAExD;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CAAC,iBAAiB,EAAE,MAAM,EAAE,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAExG;AAED,qFAAyC;AACzC,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACnC;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,iBAAiB,EAAE,MAAM,EAAE,eAAe,EAAE,OAAO,GAAG,wBAAwB,CAIpH;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GAAG,OAAO,CAGrF","sourcesContent":["/**\n * 中途引导落账提醒的探测核心（设计 `docs/design/中途引导与任务状态联动设计.md`\n * §4.1 路线 A、§7 S5；第二层强化，第一层常驻纪律在 goal 插件的\n * TASK_TOOLS_GUIDE）。全部逻辑为纯函数：输入是输入到达信号 + 既有状态，输出是\n * 是否注入与新状态；entry.ts 只做公共面接线与闭包状态持有。\n *\n * 探测选型（实施前源码验证，见 README \"探测结论\"）：\n * - `input.received@1` 不流经 `CapabilityAPI.subscribe` 可见的插件间事件总线\n *   （宿主从不向该总线发布宿主事件；它只走 lifecycle 目录通道），且其派发为\n *   fire-and-forget 异步（`agent-session.ts` 的 `void dispatchInputReceived...`），\n *   相对 run 激活（`runDefaultLoop` 置 `_isAgentRunActive`）无顺序保证——在派发\n *   时刻读 `isIdle()` 对\"新 prompt 开新 run\"路径是竞态，无法确定性地满足\n *   \"首请求/新回合首请求不提醒\"。\n * - 因此探测事件取 `beforeInput` loop 钩子：宿主在 `_runInputHandlers` 内联\n *   await 该链，先于 prompt() 的 isStreaming 分支与 run 激活、也先于 steer/\n *   followUp 入队返回。钩子调用时刻读 `isIdle()` 因此是确定性的：\n *   idle === 该输入开新 run（\"run-start\"），busy === 该输入是运行中到达的\n *   steering/followUp（\"steer\"）。这正是本插件需要的\"run 内新增 user 消息 vs\n *   新 run 首条\"判别器，且与 transformContext 同属 loop-hook 公共通道。\n *\n * 压缩边界：本路线不维护消息计数基线，不存在\"压缩后基线失真\"问题。压缩期间\n * `isIdle()` 为 false（isIdle = !runActive && !compacting），压缩窗口内到达的\n * 引导照常置 pending，压缩后的下一请求照常注入——\"压缩不丢失引导提醒\"由构造\n * 保证（测试矩阵钉住）。\n */\n\n/** 注入消息的 customType（标记来源；display:false，仅存在于该次请求视图）。 */\nexport const STEERING_GUARD_CUSTOM_TYPE = \"steering_guard\";\n\n/**\n * 任务面工具名（生效边界，设计 §3.7）：这些工具全部不在场（readonly 会话或\n * 用户禁用任务面插件）时，引导落账无承载面，不注入提醒。\n */\nexport const TASK_FACE_TOOL_NAMES: readonly string[] = [\n\t\"goal_set\",\n\t\"plan_set\",\n\t\"todo_update\",\n\t\"workflow_set\",\n\t\"workflow_advance\",\n];\n\n/** 注入到请求视图尾部的提醒文本（英文，≤60 词，契约固定措辞）。 */\nexport const STEERING_GUARD_REMINDER_TEXT =\n\t\"[steering-guard] Mid-run user input arrived. Apply the steering discipline: classify it (background/add/modify/cancel/pivot/fork), settle required state changes this turn via the task tools — workflow-level consequences first, then plan/goal, todos last; touch only affected records; a cancelled todo needs the user's line as evidence.\";\n\n/**\n * 结构化镜像宿主 `core/messages.ts` 的 CustomMessage（同 loop-guard 先例：内核\n * 类型不跨入插件面，字段漂移由宿主 e2e 拦截）。本插件只生产 display:false 的\n * 模型面提醒，不写 context.messages、不进 newMessages，故不持久化。\n */\nexport interface SteeringGuardReminderMessage {\n\trole: \"custom\";\n\tcustomType: string;\n\tcontent: string;\n\tdisplay: boolean;\n\ttimestamp: number;\n}\n\n/** display:false 的引导落账提醒消息（transformContext 注入用，同请求视图内生存）。 */\nexport function createSteeringGuardReminder(): SteeringGuardReminderMessage {\n\treturn {\n\t\trole: \"custom\",\n\t\tcustomType: STEERING_GUARD_CUSTOM_TYPE,\n\t\tcontent: STEERING_GUARD_REMINDER_TEXT,\n\t\tdisplay: false,\n\t\ttimestamp: Date.now(),\n\t};\n}\n\n/**\n * 输入到达信号：\"run-start\" = 该输入开启新 run（isIdle 为 true 时收到）；\n * \"steer\" = 该输入在 run（或压缩）进行中到达。\n */\nexport type SteeringInputSignal = \"run-start\" | \"steer\";\n\n/**\n * 吸收一个输入到达信号，返回新的 pending 计数。\n *\n * - \"run-start\"：新 run 的首条输入就是本轮 prompt 本身，不是中途引导——清零\n *   pending（同时丢弃上一 run 中止后残留的未消费计数，防止跨 run 泄漏提醒）。\n * - \"steer\"：运行中到达一条引导，pending 加一。计数而非布尔：同一 run 内连发\n *   两条引导各提醒一次（每次请求消费一条；两条在同一次请求前到达时，分两次\n *   请求各注入一次）。\n */\nexport function absorbSteeringInputSignal(pendingSteerCount: number, signal: SteeringInputSignal): number {\n\treturn signal === \"run-start\" ? 0 : pendingSteerCount + 1;\n}\n\n/** 一次注入判定的输出：是否注入 + 消费后的新 pending 计数。 */\nexport interface SteeringReminderDecision {\n\treadonly inject: boolean;\n\treadonly pendingSteerCount: number;\n}\n\n/**\n * 注入判定：pending > 0 且任务面在场时注入一条提醒并消费一个计数；任务面缺席\n * 时保留计数（本请求不注入，下一请求再判——工具面可能在 run 内动态恢复）；\n * pending 为 0 时维持去重（同一引导只提醒一次、重放不重复提醒）。\n */\nexport function decideSteeringReminder(pendingSteerCount: number, taskFacePresent: boolean): SteeringReminderDecision {\n\tif (pendingSteerCount <= 0) return { inject: false, pendingSteerCount: 0 };\n\tif (!taskFacePresent) return { inject: false, pendingSteerCount };\n\treturn { inject: true, pendingSteerCount: pendingSteerCount - 1 };\n}\n\n/**\n * 任务面在场判定（生效边界，设计 §3.7）：`getActiveTools` 不可用（SessionAPI\n * 可选面缺席）时视为在场——宁可多提醒；在场列表与任务面工具无交集时不注入。\n */\nexport function isTaskFacePresent(activeTools: readonly string[] | undefined): boolean {\n\tif (!activeTools) return true;\n\treturn TASK_FACE_TOOL_NAMES.some((name) => activeTools.includes(name));\n}\n"]}

package/dist/detector.js

@@ -0,0 +1,84 @@
+/**
+ * 中途引导落账提醒的探测核心（设计 `docs/design/中途引导与任务状态联动设计.md`
+ * §4.1 路线 A、§7 S5；第二层强化，第一层常驻纪律在 goal 插件的
+ * TASK_TOOLS_GUIDE）。全部逻辑为纯函数：输入是输入到达信号 + 既有状态，输出是
+ * 是否注入与新状态；entry.ts 只做公共面接线与闭包状态持有。
+ *
+ * 探测选型（实施前源码验证，见 README "探测结论"）：
+ * - `input.received@1` 不流经 `CapabilityAPI.subscribe` 可见的插件间事件总线
+ *   （宿主从不向该总线发布宿主事件；它只走 lifecycle 目录通道），且其派发为
+ *   fire-and-forget 异步（`agent-session.ts` 的 `void dispatchInputReceived...`），
+ *   相对 run 激活（`runDefaultLoop` 置 `_isAgentRunActive`）无顺序保证——在派发
+ *   时刻读 `isIdle()` 对"新 prompt 开新 run"路径是竞态，无法确定性地满足
+ *   "首请求/新回合首请求不提醒"。
+ * - 因此探测事件取 `beforeInput` loop 钩子：宿主在 `_runInputHandlers` 内联
+ *   await 该链，先于 prompt() 的 isStreaming 分支与 run 激活、也先于 steer/
+ *   followUp 入队返回。钩子调用时刻读 `isIdle()` 因此是确定性的：
+ *   idle === 该输入开新 run（"run-start"），busy === 该输入是运行中到达的
+ *   steering/followUp（"steer"）。这正是本插件需要的"run 内新增 user 消息 vs
+ *   新 run 首条"判别器，且与 transformContext 同属 loop-hook 公共通道。
+ *
+ * 压缩边界：本路线不维护消息计数基线，不存在"压缩后基线失真"问题。压缩期间
+ * `isIdle()` 为 false（isIdle = !runActive && !compacting），压缩窗口内到达的
+ * 引导照常置 pending，压缩后的下一请求照常注入——"压缩不丢失引导提醒"由构造
+ * 保证（测试矩阵钉住）。
+ */
+/** 注入消息的 customType（标记来源；display:false，仅存在于该次请求视图）。 */
+export const STEERING_GUARD_CUSTOM_TYPE = "steering_guard";
+/**
+ * 任务面工具名（生效边界，设计 §3.7）：这些工具全部不在场（readonly 会话或
+ * 用户禁用任务面插件）时，引导落账无承载面，不注入提醒。
+ */
+export const TASK_FACE_TOOL_NAMES = [
+    "goal_set",
+    "plan_set",
+    "todo_update",
+    "workflow_set",
+    "workflow_advance",
+];
+/** 注入到请求视图尾部的提醒文本（英文，≤60 词，契约固定措辞）。 */
+export const STEERING_GUARD_REMINDER_TEXT = "[steering-guard] Mid-run user input arrived. Apply the steering discipline: classify it (background/add/modify/cancel/pivot/fork), settle required state changes this turn via the task tools — workflow-level consequences first, then plan/goal, todos last; touch only affected records; a cancelled todo needs the user's line as evidence.";
+/** display:false 的引导落账提醒消息（transformContext 注入用，同请求视图内生存）。 */
+export function createSteeringGuardReminder() {
+    return {
+        role: "custom",
+        customType: STEERING_GUARD_CUSTOM_TYPE,
+        content: STEERING_GUARD_REMINDER_TEXT,
+        display: false,
+        timestamp: Date.now(),
+    };
+}
+/**
+ * 吸收一个输入到达信号，返回新的 pending 计数。
+ *
+ * - "run-start"：新 run 的首条输入就是本轮 prompt 本身，不是中途引导——清零
+ *   pending（同时丢弃上一 run 中止后残留的未消费计数，防止跨 run 泄漏提醒）。
+ * - "steer"：运行中到达一条引导，pending 加一。计数而非布尔：同一 run 内连发
+ *   两条引导各提醒一次（每次请求消费一条；两条在同一次请求前到达时，分两次
+ *   请求各注入一次）。
+ */
+export function absorbSteeringInputSignal(pendingSteerCount, signal) {
+    return signal === "run-start" ? 0 : pendingSteerCount + 1;
+}
+/**
+ * 注入判定：pending > 0 且任务面在场时注入一条提醒并消费一个计数；任务面缺席
+ * 时保留计数（本请求不注入，下一请求再判——工具面可能在 run 内动态恢复）；
+ * pending 为 0 时维持去重（同一引导只提醒一次、重放不重复提醒）。
+ */
+export function decideSteeringReminder(pendingSteerCount, taskFacePresent) {
+    if (pendingSteerCount <= 0)
+        return { inject: false, pendingSteerCount: 0 };
+    if (!taskFacePresent)
+        return { inject: false, pendingSteerCount };
+    return { inject: true, pendingSteerCount: pendingSteerCount - 1 };
+}
+/**
+ * 任务面在场判定（生效边界，设计 §3.7）：`getActiveTools` 不可用（SessionAPI
+ * 可选面缺席）时视为在场——宁可多提醒；在场列表与任务面工具无交集时不注入。
+ */
+export function isTaskFacePresent(activeTools) {
+    if (!activeTools)
+        return true;
+    return TASK_FACE_TOOL_NAMES.some((name) => activeTools.includes(name));
+}
+//# sourceMappingURL=detector.js.map

package/dist/detector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"detector.js","sourceRoot":"","sources":["../src/detector.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,uGAAuD;AACvD,MAAM,CAAC,MAAM,0BAA0B,GAAG,gBAAgB,CAAC;AAE3D;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAsB;IACtD,UAAU;IACV,UAAU;IACV,aAAa;IACb,cAAc;IACd,kBAAkB;CAClB,CAAC;AAEF,iGAAuC;AACvC,MAAM,CAAC,MAAM,4BAA4B,GACxC,mVAAiV,CAAC;AAenV,8GAA8D;AAC9D,MAAM,UAAU,2BAA2B,GAAiC;IAC3E,OAAO;QACN,IAAI,EAAE,QAAQ;QACd,UAAU,EAAE,0BAA0B;QACtC,OAAO,EAAE,4BAA4B;QACrC,OAAO,EAAE,KAAK;QACd,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;KACrB,CAAC;AAAA,CACF;AAQD;;;;;;;;GAQG;AACH,MAAM,UAAU,yBAAyB,CAAC,iBAAyB,EAAE,MAA2B,EAAU;IACzG,OAAO,MAAM,KAAK,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,iBAAiB,GAAG,CAAC,CAAC;AAAA,CAC1D;AAQD;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,iBAAyB,EAAE,eAAwB,EAA4B;IACrH,IAAI,iBAAiB,IAAI,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC,EAAE,CAAC;IAC3E,IAAI,CAAC,eAAe;QAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,iBAAiB,EAAE,CAAC;IAClE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,EAAE,iBAAiB,GAAG,CAAC,EAAE,CAAC;AAAA,CAClE;AAED;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAA0C,EAAW;IACtF,IAAI,CAAC,WAAW;QAAE,OAAO,IAAI,CAAC;IAC9B,OAAO,oBAAoB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;AAAA,CACvE","sourcesContent":["/**\n * 中途引导落账提醒的探测核心（设计 `docs/design/中途引导与任务状态联动设计.md`\n * §4.1 路线 A、§7 S5；第二层强化，第一层常驻纪律在 goal 插件的\n * TASK_TOOLS_GUIDE）。全部逻辑为纯函数：输入是输入到达信号 + 既有状态，输出是\n * 是否注入与新状态；entry.ts 只做公共面接线与闭包状态持有。\n *\n * 探测选型（实施前源码验证，见 README \"探测结论\"）：\n * - `input.received@1` 不流经 `CapabilityAPI.subscribe` 可见的插件间事件总线\n *   （宿主从不向该总线发布宿主事件；它只走 lifecycle 目录通道），且其派发为\n *   fire-and-forget 异步（`agent-session.ts` 的 `void dispatchInputReceived...`），\n *   相对 run 激活（`runDefaultLoop` 置 `_isAgentRunActive`）无顺序保证——在派发\n *   时刻读 `isIdle()` 对\"新 prompt 开新 run\"路径是竞态，无法确定性地满足\n *   \"首请求/新回合首请求不提醒\"。\n * - 因此探测事件取 `beforeInput` loop 钩子：宿主在 `_runInputHandlers` 内联\n *   await 该链，先于 prompt() 的 isStreaming 分支与 run 激活、也先于 steer/\n *   followUp 入队返回。钩子调用时刻读 `isIdle()` 因此是确定性的：\n *   idle === 该输入开新 run（\"run-start\"），busy === 该输入是运行中到达的\n *   steering/followUp（\"steer\"）。这正是本插件需要的\"run 内新增 user 消息 vs\n *   新 run 首条\"判别器，且与 transformContext 同属 loop-hook 公共通道。\n *\n * 压缩边界：本路线不维护消息计数基线，不存在\"压缩后基线失真\"问题。压缩期间\n * `isIdle()` 为 false（isIdle = !runActive && !compacting），压缩窗口内到达的\n * 引导照常置 pending，压缩后的下一请求照常注入——\"压缩不丢失引导提醒\"由构造\n * 保证（测试矩阵钉住）。\n */\n\n/** 注入消息的 customType（标记来源；display:false，仅存在于该次请求视图）。 */\nexport const STEERING_GUARD_CUSTOM_TYPE = \"steering_guard\";\n\n/**\n * 任务面工具名（生效边界，设计 §3.7）：这些工具全部不在场（readonly 会话或\n * 用户禁用任务面插件）时，引导落账无承载面，不注入提醒。\n */\nexport const TASK_FACE_TOOL_NAMES: readonly string[] = [\n\t\"goal_set\",\n\t\"plan_set\",\n\t\"todo_update\",\n\t\"workflow_set\",\n\t\"workflow_advance\",\n];\n\n/** 注入到请求视图尾部的提醒文本（英文，≤60 词，契约固定措辞）。 */\nexport const STEERING_GUARD_REMINDER_TEXT =\n\t\"[steering-guard] Mid-run user input arrived. Apply the steering discipline: classify it (background/add/modify/cancel/pivot/fork), settle required state changes this turn via the task tools — workflow-level consequences first, then plan/goal, todos last; touch only affected records; a cancelled todo needs the user's line as evidence.\";\n\n/**\n * 结构化镜像宿主 `core/messages.ts` 的 CustomMessage（同 loop-guard 先例：内核\n * 类型不跨入插件面，字段漂移由宿主 e2e 拦截）。本插件只生产 display:false 的\n * 模型面提醒，不写 context.messages、不进 newMessages，故不持久化。\n */\nexport interface SteeringGuardReminderMessage {\n\trole: \"custom\";\n\tcustomType: string;\n\tcontent: string;\n\tdisplay: boolean;\n\ttimestamp: number;\n}\n\n/** display:false 的引导落账提醒消息（transformContext 注入用，同请求视图内生存）。 */\nexport function createSteeringGuardReminder(): SteeringGuardReminderMessage {\n\treturn {\n\t\trole: \"custom\",\n\t\tcustomType: STEERING_GUARD_CUSTOM_TYPE,\n\t\tcontent: STEERING_GUARD_REMINDER_TEXT,\n\t\tdisplay: false,\n\t\ttimestamp: Date.now(),\n\t};\n}\n\n/**\n * 输入到达信号：\"run-start\" = 该输入开启新 run（isIdle 为 true 时收到）；\n * \"steer\" = 该输入在 run（或压缩）进行中到达。\n */\nexport type SteeringInputSignal = \"run-start\" | \"steer\";\n\n/**\n * 吸收一个输入到达信号，返回新的 pending 计数。\n *\n * - \"run-start\"：新 run 的首条输入就是本轮 prompt 本身，不是中途引导——清零\n *   pending（同时丢弃上一 run 中止后残留的未消费计数，防止跨 run 泄漏提醒）。\n * - \"steer\"：运行中到达一条引导，pending 加一。计数而非布尔：同一 run 内连发\n *   两条引导各提醒一次（每次请求消费一条；两条在同一次请求前到达时，分两次\n *   请求各注入一次）。\n */\nexport function absorbSteeringInputSignal(pendingSteerCount: number, signal: SteeringInputSignal): number {\n\treturn signal === \"run-start\" ? 0 : pendingSteerCount + 1;\n}\n\n/** 一次注入判定的输出：是否注入 + 消费后的新 pending 计数。 */\nexport interface SteeringReminderDecision {\n\treadonly inject: boolean;\n\treadonly pendingSteerCount: number;\n}\n\n/**\n * 注入判定：pending > 0 且任务面在场时注入一条提醒并消费一个计数；任务面缺席\n * 时保留计数（本请求不注入，下一请求再判——工具面可能在 run 内动态恢复）；\n * pending 为 0 时维持去重（同一引导只提醒一次、重放不重复提醒）。\n */\nexport function decideSteeringReminder(pendingSteerCount: number, taskFacePresent: boolean): SteeringReminderDecision {\n\tif (pendingSteerCount <= 0) return { inject: false, pendingSteerCount: 0 };\n\tif (!taskFacePresent) return { inject: false, pendingSteerCount };\n\treturn { inject: true, pendingSteerCount: pendingSteerCount - 1 };\n}\n\n/**\n * 任务面在场判定（生效边界，设计 §3.7）：`getActiveTools` 不可用（SessionAPI\n * 可选面缺席）时视为在场——宁可多提醒；在场列表与任务面工具无交集时不注入。\n */\nexport function isTaskFacePresent(activeTools: readonly string[] | undefined): boolean {\n\tif (!activeTools) return true;\n\treturn TASK_FACE_TOOL_NAMES.some((name) => activeTools.includes(name));\n}\n"]}

package/dist/entry.d.ts

@@ -0,0 +1,27 @@
+import type { CapabilityAPI } from "@agent-forge/plugin-sdk";
+/**
+ * Default-export factory consumed by the host's manifest plugin loader
+ * (design `docs/design/中途引导与任务状态联动设计.md` §4.1 路线 A、§7 S5：
+ * 第二层强化——检测到运行中到达的用户引导时，向下一次模型请求的视图尾部
+ * 注入一条 display:false 的引导落账提醒；第一层常驻纪律由 goal 插件的
+ * TASK_TOOLS_GUIDE 承载，本插件不重复渲染常驻文本).
+ *
+ * Detection rides the public `beforeInput` loop hook (see detector.ts for the
+ * probe record: `input.received@1` neither flows through the
+ * `CapabilityAPI.subscribe` plugin-to-plugin bus nor gives a deterministic
+ * idle/busy read at fire-and-forget delivery time, while `beforeInput` is
+ * awaited inline by the host BEFORE run activation on the prompt path and
+ * during the active run on the steer path). The reminder rides the public
+ * `transformContext` chain, appended to the final request view tail exactly
+ * like the agent-loop-policy warn reminder (display:false, not persisted —
+ * no context.messages write, no newMessages entry).
+ *
+ * Disabling this plugin (`disabledPluginIds`) removes both links. A host
+ * without `SessionAPI` leaves the guard inert (every input reads as
+ * "run-start"); a host without `getActiveTools` counts the task face as
+ * present (better one reminder too many than a silent miss).
+ */
+export default function createSteeringGuardPluginEntry(api: CapabilityAPI): {
+    dispose: () => void;
+};
+//# sourceMappingURL=entry.d.ts.map

package/dist/entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.d.ts","sourceRoot":"","sources":["../src/entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGX,aAAa,EACb,MAAM,yBAAyB,CAAC;AASjC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,OAAO,UAAU,8BAA8B,CAAC,GAAG,EAAE,aAAa,GAAG;IAAE,OAAO,EAAE,MAAM,IAAI,CAAA;CAAE,CAmClG","sourcesContent":["import type {\n\tAgentLoopBeforeInputHookV1,\n\tAgentLoopTransformContextHookV1,\n\tCapabilityAPI,\n} from \"@agent-forge/plugin-sdk\";\nimport {\n\tabsorbSteeringInputSignal,\n\tcreateSteeringGuardReminder,\n\tdecideSteeringReminder,\n\tisTaskFacePresent,\n\ttype SteeringInputSignal,\n} from \"./detector.ts\";\n\n/**\n * Default-export factory consumed by the host's manifest plugin loader\n * (design `docs/design/中途引导与任务状态联动设计.md` §4.1 路线 A、§7 S5：\n * 第二层强化——检测到运行中到达的用户引导时，向下一次模型请求的视图尾部\n * 注入一条 display:false 的引导落账提醒；第一层常驻纪律由 goal 插件的\n * TASK_TOOLS_GUIDE 承载，本插件不重复渲染常驻文本).\n *\n * Detection rides the public `beforeInput` loop hook (see detector.ts for the\n * probe record: `input.received@1` neither flows through the\n * `CapabilityAPI.subscribe` plugin-to-plugin bus nor gives a deterministic\n * idle/busy read at fire-and-forget delivery time, while `beforeInput` is\n * awaited inline by the host BEFORE run activation on the prompt path and\n * during the active run on the steer path). The reminder rides the public\n * `transformContext` chain, appended to the final request view tail exactly\n * like the agent-loop-policy warn reminder (display:false, not persisted —\n * no context.messages write, no newMessages entry).\n *\n * Disabling this plugin (`disabledPluginIds`) removes both links. A host\n * without `SessionAPI` leaves the guard inert (every input reads as\n * \"run-start\"); a host without `getActiveTools` counts the task face as\n * present (better one reminder too many than a silent miss).\n */\nexport default function createSteeringGuardPluginEntry(api: CapabilityAPI): { dispose: () => void } {\n\t/** 跨请求状态：未消费的引导提醒计数（闭包持有，决策逻辑全在 detector.ts）。 */\n\tlet pendingSteerCount = 0;\n\n\tconst beforeInput: AgentLoopBeforeInputHookV1 = async (_input) => {\n\t\t// 钩子时刻的 isIdle 是确定性的（见 detector.ts 探测记录）：idle === 该输入\n\t\t// 开新 run（清零残留计数），busy === 运行中/压缩中到达的引导。\n\t\tconst idle = api.session ? api.session.isIdle() : true;\n\t\tconst signal: SteeringInputSignal = idle ? \"run-start\" : \"steer\";\n\t\tpendingSteerCount = absorbSteeringInputSignal(pendingSteerCount, signal);\n\t\t// 纯观察位：不拦截、不改写输入文本。\n\t\treturn undefined;\n\t};\n\n\tconst transformContext: AgentLoopTransformContextHookV1 = async (messages, _signal) => {\n\t\tconst decision = decideSteeringReminder(pendingSteerCount, isTaskFacePresent(api.session?.getActiveTools?.()));\n\t\tpendingSteerCount = decision.pendingSteerCount;\n\t\tif (!decision.inject) return undefined;\n\t\t// 非变异地追加到请求视图尾部（不写 context.messages，故不持久化）；\n\t\t// 消费即计数减一：同一引导只提醒一次。\n\t\treturn [...messages, createSteeringGuardReminder()];\n\t};\n\n\tconst inputLink = api.registerLoopHook(\"beforeInput\", beforeInput);\n\t// 与 agent-loop-policy 同序理由：注册在默认上下文策略链之后，提醒落到最终\n\t// 请求视图尾部（幸存于任何策略裁剪）。\n\tconst reminderLink = api.registerLoopHook(\"transformContext\", transformContext);\n\treturn {\n\t\tdispose: () => {\n\t\t\t// Registration disposal in the capability runtime is synchronous;\n\t\t\t// void consumes the declared Promise possibility of the contract.\n\t\t\tvoid reminderLink.dispose();\n\t\t\tvoid inputLink.dispose();\n\t\t},\n\t};\n}\n"]}

package/dist/entry.js

@@ -0,0 +1,58 @@
+import { absorbSteeringInputSignal, createSteeringGuardReminder, decideSteeringReminder, isTaskFacePresent, } from "./detector.js";
+/**
+ * Default-export factory consumed by the host's manifest plugin loader
+ * (design `docs/design/中途引导与任务状态联动设计.md` §4.1 路线 A、§7 S5：
+ * 第二层强化——检测到运行中到达的用户引导时，向下一次模型请求的视图尾部
+ * 注入一条 display:false 的引导落账提醒；第一层常驻纪律由 goal 插件的
+ * TASK_TOOLS_GUIDE 承载，本插件不重复渲染常驻文本).
+ *
+ * Detection rides the public `beforeInput` loop hook (see detector.ts for the
+ * probe record: `input.received@1` neither flows through the
+ * `CapabilityAPI.subscribe` plugin-to-plugin bus nor gives a deterministic
+ * idle/busy read at fire-and-forget delivery time, while `beforeInput` is
+ * awaited inline by the host BEFORE run activation on the prompt path and
+ * during the active run on the steer path). The reminder rides the public
+ * `transformContext` chain, appended to the final request view tail exactly
+ * like the agent-loop-policy warn reminder (display:false, not persisted —
+ * no context.messages write, no newMessages entry).
+ *
+ * Disabling this plugin (`disabledPluginIds`) removes both links. A host
+ * without `SessionAPI` leaves the guard inert (every input reads as
+ * "run-start"); a host without `getActiveTools` counts the task face as
+ * present (better one reminder too many than a silent miss).
+ */
+export default function createSteeringGuardPluginEntry(api) {
+    /** 跨请求状态：未消费的引导提醒计数（闭包持有，决策逻辑全在 detector.ts）。 */
+    let pendingSteerCount = 0;
+    const beforeInput = async (_input) => {
+        // 钩子时刻的 isIdle 是确定性的（见 detector.ts 探测记录）：idle === 该输入
+        // 开新 run（清零残留计数），busy === 运行中/压缩中到达的引导。
+        const idle = api.session ? api.session.isIdle() : true;
+        const signal = idle ? "run-start" : "steer";
+        pendingSteerCount = absorbSteeringInputSignal(pendingSteerCount, signal);
+        // 纯观察位：不拦截、不改写输入文本。
+        return undefined;
+    };
+    const transformContext = async (messages, _signal) => {
+        const decision = decideSteeringReminder(pendingSteerCount, isTaskFacePresent(api.session?.getActiveTools?.()));
+        pendingSteerCount = decision.pendingSteerCount;
+        if (!decision.inject)
+            return undefined;
+        // 非变异地追加到请求视图尾部（不写 context.messages，故不持久化）；
+        // 消费即计数减一：同一引导只提醒一次。
+        return [...messages, createSteeringGuardReminder()];
+    };
+    const inputLink = api.registerLoopHook("beforeInput", beforeInput);
+    // 与 agent-loop-policy 同序理由：注册在默认上下文策略链之后，提醒落到最终
+    // 请求视图尾部（幸存于任何策略裁剪）。
+    const reminderLink = api.registerLoopHook("transformContext", transformContext);
+    return {
+        dispose: () => {
+            // Registration disposal in the capability runtime is synchronous;
+            // void consumes the declared Promise possibility of the contract.
+            void reminderLink.dispose();
+            void inputLink.dispose();
+        },
+    };
+}
+//# sourceMappingURL=entry.js.map

package/dist/entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"entry.js","sourceRoot":"","sources":["../src/entry.ts"],"names":[],"mappings":"AAKA,OAAO,EACN,yBAAyB,EACzB,2BAA2B,EAC3B,sBAAsB,EACtB,iBAAiB,GAEjB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,OAAO,UAAU,8BAA8B,CAAC,GAAkB,EAA2B;IACnG,6GAAiD;IACjD,IAAI,iBAAiB,GAAG,CAAC,CAAC;IAE1B,MAAM,WAAW,GAA+B,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;QACjE,gGAAsD;QACtD,sFAAwC;QACxC,MAAM,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;QACvD,MAAM,MAAM,GAAwB,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,OAAO,CAAC;QACjE,iBAAiB,GAAG,yBAAyB,CAAC,iBAAiB,EAAE,MAAM,CAAC,CAAC;QACzE,sDAAoB;QACpB,OAAO,SAAS,CAAC;IAAA,CACjB,CAAC;IAEF,MAAM,gBAAgB,GAAoC,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAC;QACtF,MAAM,QAAQ,GAAG,sBAAsB,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,GAAG,CAAC,OAAO,EAAE,cAAc,EAAE,EAAE,CAAC,CAAC,CAAC;QAC/G,iBAAiB,GAAG,QAAQ,CAAC,iBAAiB,CAAC;QAC/C,IAAI,CAAC,QAAQ,CAAC,MAAM;YAAE,OAAO,SAAS,CAAC;QACvC,4FAA4C;QAC5C,yDAAqB;QACrB,OAAO,CAAC,GAAG,QAAQ,EAAE,2BAA2B,EAAE,CAAC,CAAC;IAAA,CACpD,CAAC;IAEF,MAAM,SAAS,GAAG,GAAG,CAAC,gBAAgB,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;IACnE,oGAAgD;IAChD,yDAAqB;IACrB,MAAM,YAAY,GAAG,GAAG,CAAC,gBAAgB,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CAAC;IAChF,OAAO;QACN,OAAO,EAAE,GAAG,EAAE,CAAC;YACd,kEAAkE;YAClE,kEAAkE;YAClE,KAAK,YAAY,CAAC,OAAO,EAAE,CAAC;YAC5B,KAAK,SAAS,CAAC,OAAO,EAAE,CAAC;QAAA,CACzB;KACD,CAAC;AAAA,CACF","sourcesContent":["import type {\n\tAgentLoopBeforeInputHookV1,\n\tAgentLoopTransformContextHookV1,\n\tCapabilityAPI,\n} from \"@agent-forge/plugin-sdk\";\nimport {\n\tabsorbSteeringInputSignal,\n\tcreateSteeringGuardReminder,\n\tdecideSteeringReminder,\n\tisTaskFacePresent,\n\ttype SteeringInputSignal,\n} from \"./detector.ts\";\n\n/**\n * Default-export factory consumed by the host's manifest plugin loader\n * (design `docs/design/中途引导与任务状态联动设计.md` §4.1 路线 A、§7 S5：\n * 第二层强化——检测到运行中到达的用户引导时，向下一次模型请求的视图尾部\n * 注入一条 display:false 的引导落账提醒；第一层常驻纪律由 goal 插件的\n * TASK_TOOLS_GUIDE 承载，本插件不重复渲染常驻文本).\n *\n * Detection rides the public `beforeInput` loop hook (see detector.ts for the\n * probe record: `input.received@1` neither flows through the\n * `CapabilityAPI.subscribe` plugin-to-plugin bus nor gives a deterministic\n * idle/busy read at fire-and-forget delivery time, while `beforeInput` is\n * awaited inline by the host BEFORE run activation on the prompt path and\n * during the active run on the steer path). The reminder rides the public\n * `transformContext` chain, appended to the final request view tail exactly\n * like the agent-loop-policy warn reminder (display:false, not persisted —\n * no context.messages write, no newMessages entry).\n *\n * Disabling this plugin (`disabledPluginIds`) removes both links. A host\n * without `SessionAPI` leaves the guard inert (every input reads as\n * \"run-start\"); a host without `getActiveTools` counts the task face as\n * present (better one reminder too many than a silent miss).\n */\nexport default function createSteeringGuardPluginEntry(api: CapabilityAPI): { dispose: () => void } {\n\t/** 跨请求状态：未消费的引导提醒计数（闭包持有，决策逻辑全在 detector.ts）。 */\n\tlet pendingSteerCount = 0;\n\n\tconst beforeInput: AgentLoopBeforeInputHookV1 = async (_input) => {\n\t\t// 钩子时刻的 isIdle 是确定性的（见 detector.ts 探测记录）：idle === 该输入\n\t\t// 开新 run（清零残留计数），busy === 运行中/压缩中到达的引导。\n\t\tconst idle = api.session ? api.session.isIdle() : true;\n\t\tconst signal: SteeringInputSignal = idle ? \"run-start\" : \"steer\";\n\t\tpendingSteerCount = absorbSteeringInputSignal(pendingSteerCount, signal);\n\t\t// 纯观察位：不拦截、不改写输入文本。\n\t\treturn undefined;\n\t};\n\n\tconst transformContext: AgentLoopTransformContextHookV1 = async (messages, _signal) => {\n\t\tconst decision = decideSteeringReminder(pendingSteerCount, isTaskFacePresent(api.session?.getActiveTools?.()));\n\t\tpendingSteerCount = decision.pendingSteerCount;\n\t\tif (!decision.inject) return undefined;\n\t\t// 非变异地追加到请求视图尾部（不写 context.messages，故不持久化）；\n\t\t// 消费即计数减一：同一引导只提醒一次。\n\t\treturn [...messages, createSteeringGuardReminder()];\n\t};\n\n\tconst inputLink = api.registerLoopHook(\"beforeInput\", beforeInput);\n\t// 与 agent-loop-policy 同序理由：注册在默认上下文策略链之后，提醒落到最终\n\t// 请求视图尾部（幸存于任何策略裁剪）。\n\tconst reminderLink = api.registerLoopHook(\"transformContext\", transformContext);\n\treturn {\n\t\tdispose: () => {\n\t\t\t// Registration disposal in the capability runtime is synchronous;\n\t\t\t// void consumes the declared Promise possibility of the contract.\n\t\t\tvoid reminderLink.dispose();\n\t\t\tvoid inputLink.dispose();\n\t\t},\n\t};\n}\n"]}

package/package.json

@@ -1,6 +1,51 @@
 {
-  "name": "@ai-agent-forge/plugin-steering-guard",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@ai-agent-forge/plugin-steering-guard",
+	"version": "0.88.16",
+	"description": "Steering-guard capability plugin for Agent Forge (mid-run steering reminder injected into the request view)",
+	"type": "module",
+	"main": "./dist/entry.js",
+	"types": "./dist/entry.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/entry.d.ts",
+			"import": "./dist/entry.js"
+		}
+	},
+	"files": [
+		"dist",
+		"agent-forge.json",
+		"plugin.json",
+		"README.md"
+	],
+	"scripts": {
+		"clean": "shx rm -rf dist",
+		"build": "tsgo -p tsconfig.build.json",
+		"test": "vitest --run",
+		"prepublishOnly": "npm run clean && npm run build",
+		"test:coverage": "vitest --run --coverage"
+	},
+	"keywords": [
+		"agent-forge",
+		"plugin",
+		"steering-guard"
+	],
+	"author": "Agent Forge contributors",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/agent-forge/agent-forge.git",
+		"directory": "plugins/steering-guard"
+	},
+	"bugs": {
+		"url": "https://github.com/agent-forge/agent-forge/issues"
+	},
+	"homepage": "https://github.com/agent-forge/agent-forge#readme",
+	"engines": {
+		"node": ">=22.19.0"
+	},
+	"dependencies": {},
+	"devDependencies": {
+		"shx": "0.3.4",
+		"vitest": "4.1.11"
+	}
+}

package/plugin.json

@@ -0,0 +1,7 @@
+{
+	"id": "agent-forge.plugin.steering-guard",
+	"version": "0.88.16",
+	"apiVersion": "1-draft",
+	"entry": "./dist/entry.js",
+	"hostVersion": ">=0.88.0"
+}