dsh-offpeak-guard 0.3.2 → 0.3.4

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.3.4 — 2026-11-15
+
+- 收紧模型工具的会话边界：`offpeak_plan` 的 add/list/remove/clear 只能作用于调用者当前会话；显式传其它 `sessionId` 会被拒绝。
+- `offpeak_guard` 的 `pause_now` / `resume_now` / `run_plans_now` / `exempt` / `unexempt` 全部只作用于当前会话；`pause_now` 不再全局 cancel 其它会话。
+- 移除模型工具修改全局 `pause_mode` 的能力，峰时策略只能由用户在设置面板切换。
+- `offpeak_status` / `offpeak_guard status` 只返回当前会话的暂停、豁免、规划明细；规则/倒计时仍为全局只读信息。
+- 规划新增 `createdBySessionId`；自动执行时只投递创建者与目标一致的规划，旧版无创建者的规划标记失败并跳过。
+- 允许目标会话删除/清空自己名下的旧版规划（没有 `createdBySessionId` 但 `sessionId` 匹配）。
+- 新增 `test/guard-authorization.test.mjs`（真实 guard 的旧计划隔离、owner 过滤、addPlan 校验）和工具层 pause/status 授权测试。
+
+## 0.3.3 — 2026-11-14
+
+- 设置接口 `/plugins/dsh-offpeak-guard/action` 补上准入：路由只在 `webServer` 与 `connection` 两个服务都在位时注册，每个请求先过 `connection.requestRejection(req)`（Host/Origin 校验 + 浏览器令牌鉴权），返回 401/403 直接拒绝。此前本机任意网页都能改会话豁免、峰谷规则和暂停方式。
+- 拿不到 `connection` 或它抛错时一律按拒绝处理（失败关闭），不退回到只检查 Host/Origin/回环地址。
+- 请求体加 64 KiB 上限，超出返回 413；其余错误仍返回 400。
+- 新增 `test/admission.test.mjs`：覆盖缺服务、读取抛错、`requestRejection` 抛错、放行与 401/403 透传五条路径。
+- 适配 DSH 0.2.2-rc.2 的 `@deepseek-ai/dsh-client-connection` 服务约定（`requestRejection` 接收 `{ headers }`）。
+
 ## 0.3.2 — 2026-11-06
 
 - 修复设置面板切换峰时策略时报 `Unexpected end of JSON input`：Host 启动顺序可能让 `webServer` 在插件 apply 时尚未就绪，导致设置路由根本没注册；改用 `ctx.inject(['webServer'], ...)` 后再挂载路由。

package/README.en.md

@@ -10,7 +10,8 @@ Schedule work around **DeepSeek peak/off-peak pricing** inside DeepSeek Harness:
 - **Time awareness**: per DeepSeek's official pricing, Beijing-time weekdays (excluding Chinese statutory holidays) `09:00–12:00` and `14:00–18:00` are peak; every other hour (weekends, holidays, lunch, night) is off-peak at 50%. Holidays sync from a public API with a built-in 2026 fallback.
 - **Model awareness**: exact `provider / model` detection; models containing `deepseek` are managed by default, and the settings panel can toggle each model. `peakPricedModels` / `exemptModels` provide exact control.
 - **Peak strategy**: choose immediate pause or finish the current turn first; if a session has running subagents, they are allowed to finish and the parent is paused afterwards, then resumed at off-peak.
-- **Session exemptions**: exempt any session from the guard (settings panel or `offpeak_guard exempt/unexempt`), and un-exempt it at any time.
+- **Session exemptions**: exempt the current session via `offpeak_guard exempt/unexempt`, or any session from the settings panel / sidebar row; un-exempt at any time. Model tools cannot target other sessions.
+- **Tool boundary**: every session-level `offpeak_plan` / `offpeak_guard` action is limited to the calling session; tools cannot deliver prompts to, resume, or wake another session. Cross-session exemptions are a user action in the UI.
 - **Work planning**:
   - peak starts → running tasks are paused (the pending inbox is kept, no message is lost);
   - a task started during peak → stopped immediately, no peak-priced tokens spent;
@@ -38,7 +39,7 @@ Click the clock to open the settings panel:
 | --- | --- |
 | `offpeak_status` | Current window, next switch, whether the current model is peak-priced, paused/planned lists |
 | `offpeak_plan` | `add` / `list` / `remove` / `clear` off-peak plans |
-| `offpeak_guard` | `status` / `pause_now` / `resume_now` / `run_plans_now` manual control |
+| `offpeak_guard` | `status` / `pause_now` / `resume_now` / `run_plans_now` manual control (all limited to the current session; global strategy lives in settings) |
 
 ## Configuration
 
@@ -110,6 +111,15 @@ Click the sidebar clock to open it:
 - **Session exemptions**: searchable list of live root sessions; hover a session row in the left sidebar for a shield button, or use the **Exempt this session** button in the composer strip to toggle the current conversation directly;
 - **Holidays**: show the dynamic sync state.
 
+### Route admission
+
+The settings route `/plugins/dsh-offpeak-guard/action` goes through host authentication:
+
+- the route is only registered once both `webServer` and `connection` are available;
+- every request passes `connection.requestRejection(req)` first — its Host/Origin fence stops DNS rebinding and cross-site calls, and its browser authentication stops pages that never logged in; a 401/403 is answered before any business logic runs;
+- a missing `connection`, or one that throws, rejects the request (fail closed); there is no fallback to checking only Host, Origin or the loopback address;
+- request bodies are capped at 64 KiB and answer 413 above that.
+
 ## Subagents and waiting
 
 - Running subagents are allowed to finish; the parent is paused after the last child ends and resumed off-peak;
@@ -126,6 +136,14 @@ State and snapshots live in `$DSH_HOME/offpeak-guard/`:
 
 Nothing is written into user workspaces.
 
+## Tool session boundaries
+
+- `offpeak_plan` can only add/list/remove/clear plans for the session that calls it; any other `sessionId` is rejected.
+- `offpeak_guard`'s `pause_now`, `resume_now`, `run_plans_now`, `exempt`, and `unexempt` only act on the calling session; omitting `sessionId` never falls back to "all sessions". `status` returns only the current session's details, and `pause_mode` can only be changed by the user in the settings panel.
+- Automatic peak pause/resume is unchanged: the guard still handles every root session by rule.
+- Legacy plans without `createdBySessionId` have no provable authorization source; they are marked failed and skipped, and must be re-created from the target session.
+- Cross-session exemptions are a user action in the settings panel or the sidebar row; model tools provide no cross-session delivery.
+
 ## How resuming works
 
 Pause uses `sessionController.cancel`, which ends only the current turn and keeps the pending inbox. Resume uses `sessionController.prompt` to deliver a "continue where you left off" instruction to the original session; cold sessions are woken automatically. The resume text mentions the interruption time and the paused model so it stays traceable in the conversation.
@@ -137,6 +155,6 @@ Pause uses `sessionController.cancel`, which ends only the current turn and keep
 - Named presets have fixed windows; use `preset: custom` for other providers or self-hosted pricing.
 - Only root sessions with a working directory are handled; subagent sessions are skipped so parents do not hang.
 - Subagent results are consumed by the parent after it resumes; the guard stops the parent at child completion but cannot intercept messages already written into the parent history.
-- A session exemption affects future pauses/resumes only; use `resume_now` to resume an already paused session.
+- A session exemption affects future pauses/resumes only; use `resume_now` in the current session to resume an already paused task.
 - A plugin restart does not cancel tasks that are already running (so installing the plugin cannot kill the current conversation); the next peak or new task follows the rules again.
-- Manual `resume_now` grants those sessions a 10-minute grace period so they are not paused again immediately.
+- Manual `resume_now` grants the current session a 10-minute grace period so it is not paused again immediately.

package/README.md

@@ -10,7 +10,8 @@
 - **时间识别**：按 DeepSeek 官方规则，北京时间周一至周五（不含中国法定节假日）`09:00–12:00`、`14:00–18:00` 为峰值原价；其余时间（含周末、法定节假日全天）为谷价，按 5 折计费。节假日默认从公开 API 动态同步，失败时回退内置 2026 列表。
 - **模型识别**：按会话真实 `provider / model` 精确判断；默认名字含 `deepseek` 的模型受管理，可在设置面板逐模型开关，或用 `peakPricedModels` / `exemptModels` 精确控制。
 - **峰时策略**：可选「立即暂停」或「完成当前轮后暂停」；会话有子代理在跑时先放行子代理，子代理结束后再暂停父会话，谷价开始时恢复。
-- **会话豁免**：可让某个会话不参与插件的暂停/恢复（设置面板或 `offpeak_guard exempt/unexempt`），随时取消豁免。
+- **会话豁免**：可让某个会话不参与插件的暂停/恢复（设置面板、左侧会话行，或 `offpeak_guard exempt/unexempt` 当前会话），随时取消豁免。
+- **工具边界**：`offpeak_plan` / `offpeak_guard` 的所有会话级操作都只作用于调用它的当前会话；不能通过工具向其它会话投递指令、恢复任务或唤醒 Agent。跨会话的豁免请在界面里由用户操作。
 - **工作规划**：
   - 峰时开始 → 暂停正在运行的任务（保留待处理队列，不丢消息）；
   - 峰时新起的任务 → 立即停住，不花峰时 token；
@@ -38,8 +39,8 @@
 | 工具 | 用途 |
 | --- | --- |
 | `offpeak_status` | 当前时段、下次切换、当前模型是否适用、暂停与规划清单 |
-| `offpeak_plan` | `add` / `list` / `remove` / `clear` 错峰规划 |
-| `offpeak_guard` | `status` / `pause_now` / `resume_now` / `run_plans_now` 手动控制 |
+| `offpeak_plan` | `add` / `list` / `remove` / `clear` 错峰规划（只作用于当前会话） |
+| `offpeak_guard` | `status` / `pause_now` / `resume_now` / `run_plans_now` 手动控制（全部只作用于当前会话；全局策略在设置面板） |
 
 ## 配置
 
@@ -112,6 +113,15 @@
 
 面板里的修改立即生效并持久化。
 
+### 接口准入
+
+设置接口 `/plugins/dsh-offpeak-guard/action` 走宿主认证，不对外开放：
+
+- 路由在 `webServer` 与 `connection` 两个服务都在位时才注册；
+- 每个请求先过 `connection.requestRejection(req)`——Host/Origin 校验挡住 DNS rebinding 与跨站调用，浏览器令牌鉴权挡住没登录的本机网页；返回 401/403 时直接拒绝，不进入业务逻辑；
+- 拿不到 `connection` 或它抛错时一律按拒绝处理（失败关闭），不会退回只检查 Host、Origin 或回环地址；
+- 请求体上限 64 KiB，超出返回 413。
+
 ## 子代理与等待
 
 - 峰时开始时若会话有**正在运行的子代理**，先放行父会话与子代理；
@@ -129,6 +139,14 @@
 
 不写用户工作区。
 
+## 工具会话边界
+
+- `offpeak_plan` 只能为**调用工具的那个会话**排定/查看/删除/清空规划；显式传其它 `sessionId` 会被拒绝。
+- `offpeak_guard` 的 `pause_now`、`resume_now`、`run_plans_now`、`exempt`、`unexempt` 同样只作用于当前会话；省略 `sessionId` 也不会退化成“操作所有会话”。`status` 只返回当前会话的暂停/豁免/规划明细，`pause_mode` 不再由模型工具修改，只能在设置面板切换。
+- 自动峰谷暂停/恢复不受影响：守卫仍会按规则处理所有根会话。
+- 旧版本创建的、没有 `createdBySessionId` 的规划没有可证明的授权来源，自动执行时会被标记失败并跳过，需要从目标会话重新排定。
+- 跨会话的豁免/取消豁免请在设置面板或左侧会话行由用户操作；工具不提供跨会话投递。
+
 ## 恢复是怎么做的
 
 暂停用 `sessionController.cancel`，它只结束当前一轮、保留待处理队列；恢复用 `sessionController.prompt` 向原会话投递一条「继续上次中断处」的指令，冷会话会被自动唤醒。恢复文本会注明中断时间与被暂停的模型，方便对话里追溯。
@@ -140,6 +158,6 @@
 - 命名预设的窗口是固定的；需要其他供应商/自建计价时用 `preset: custom` 配 `peakWindows`。
 - 只处理有工作目录、非子代理的根会话，避免打断子代理让父会话卡住。
 - 子代理结果在父会话恢复后由模型继续消费；插件能在子代理结束时停住父会话，但无法在传输层拦截已经进入父会话历史的消息。
-- 「会话豁免」只影响后续暂停/恢复，不会自动把已经暂停的任务立即恢复；需要时用 `resume_now`。
+- 「会话豁免」只影响后续暂停/恢复，不会自动把已经暂停的任务立即恢复；需要时在当前会话用 `resume_now`。
 - 插件自身重启时不会主动打断正在跑的任务（避免刚安装就停掉当前对话）；之后进入峰时或新起任务仍按规则处理。
-- 手动「立即恢复」会给这些会话 10 分钟豁免，避免峰时刚恢复又被停回去。
+- 手动「立即恢复」会给当前会话 10 分钟豁免，避免峰时刚恢复又被停回去。

package/index.js

@@ -149,11 +149,25 @@ export function envConfig(env = process.env) {
   return out;
 }
 
+/** 设置接口只收几个字段的小 JSON，超过这个体积按可疑请求拒绝。 */
+const MAX_BODY_BYTES = 64 * 1024;
+
 async function readJsonBody(req) {
-  let raw = '';
-  for await (const chunk of req) raw += chunk;
-  if (raw === '') return {};
-  return JSON.parse(raw);
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk?.byteLength ?? Buffer.byteLength(String(chunk));
+    if (size > MAX_BODY_BYTES) {
+      // 先排空再拒绝，让客户端读到响应而不是被一刀切断连接。
+      req.resume();
+      const error = new Error('request body too large');
+      error.statusCode = 413;
+      throw error;
+    }
+    chunks.push(chunk);
+  }
+  if (size === 0) return {};
+  return JSON.parse(Buffer.concat(chunks, size).toString('utf8'));
 }
 
 function sendJson(res, status, payload) {
@@ -164,6 +178,33 @@ function sendJson(res, status, payload) {
   res.end(body);
 }
 
+/**
+ * 设置路由的准入栅栏。
+ *
+ * `connection.requestRejection` 是宿主唯一的本机接口准入点：它同时做 Host/Origin
+ * 校验（挡 DNS rebinding 和跨站请求）与浏览器令牌鉴权（挡没登录的本机网页）。
+ * 没有它，本机任意网页都能改会话豁免、峰谷规则和暂停方式。
+ *
+ * 拿不到 `connection`、或它自己抛错时一律拒绝（失败关闭），不退回到只检查
+ * Host/Origin/回环地址——那条路挡不住别的网页。
+ */
+export function admissionRejection(ctx, req) {
+  let connection;
+  try {
+    connection = Reflect.get(ctx, 'connection');
+  } catch {
+    return 403;
+  }
+  if (connection === undefined || connection === null || typeof connection.requestRejection !== 'function') {
+    return 403;
+  }
+  try {
+    return connection.requestRejection({ headers: req.headers }) ?? undefined;
+  } catch {
+    return 403;
+  }
+}
+
 export function apply(ctx, rawConfig = {}) {
   const config = { ...(rawConfig ?? {}), ...envConfig() };
   const guard = createGuard(ctx, config);
@@ -197,7 +238,7 @@ export function apply(ctx, rawConfig = {}) {
     };
   }, 'offpeak-guard: tools');
 
-  ctx.inject(['webServer'], (webCtx) => {
+  ctx.inject(['webServer', 'connection'], (webCtx) => {
     webCtx.effect(
       () =>
         webCtx.webServer.register({
@@ -205,6 +246,11 @@ export function apply(ctx, rawConfig = {}) {
           path: '/plugins/dsh-offpeak-guard',
           async handler(req, res) {
             try {
+              const rejection = admissionRejection(webCtx, req);
+              if (rejection !== undefined) {
+                sendJson(res, rejection, { ok: false, error: 'unauthorized' });
+                return;
+              }
               const url = new URL(req.url || '/', 'http://x');
               const rest = url.pathname.replace(/^\/plugins\/dsh-offpeak-guard/, '') || '/';
               if (req.method !== 'POST' || rest !== '/action') {
@@ -234,7 +280,8 @@ export function apply(ctx, rawConfig = {}) {
               }
               sendJson(res, 400, { ok: false, error: 'unknown action' });
             } catch (error) {
-              sendJson(res, 400, { ok: false, error: String(error?.message ?? error) });
+              const status = Number.isInteger(error?.statusCode) ? error.statusCode : 400;
+              sendJson(res, status, { ok: false, error: String(error?.message ?? error) });
             }
           },
         }),

package/lib/guard.js

@@ -293,6 +293,10 @@ export function createGuard(ctx, config = {}) {
     }
     const label = await resolveModelLabel(selected.provider, selected.model);
     const paused = state.interrupted.filter((item) => item.status === 'paused');
+    const interruptedItems = state.interrupted.filter(
+      (item) =>
+        item.status === 'paused' || item.status === 'waiting-turn' || item.status === 'waiting-children',
+    );
     const plans = state.plans.filter((item) => item.status === 'queued');
     const sessions = {};
     for (const agent of liveAgents().slice(0, 30)) {
@@ -353,19 +357,22 @@ export function createGuard(ctx, config = {}) {
         deferNewTurnsOnPeak: options.deferNewTurnsOnPeak,
         resumeOnOffPeak: options.resumeOnOffPeak,
       },
-      interrupted: paused.map((item) => ({
+      interrupted: interruptedItems.map((item) => ({
         id: item.id,
         sessionId: item.sessionId,
         title: item.title,
         model: item.model,
         at: item.at,
         cause: item.cause,
+        status: item.status,
       })),
       plans: plans.map((item) => ({
         id: item.id,
         title: item.title,
+        sessionId: item.sessionId,
         createdAt: item.createdAt,
         hasPrompt: typeof item.prompt === 'string' && item.prompt.trim() !== '',
+        createdBySessionId: item.createdBySessionId ?? null,
       })),
       counts: {
         interrupted: paused.length,
@@ -434,7 +441,7 @@ export function createGuard(ctx, config = {}) {
    * 有子代理在跑时先放行，子代理结束后再按规则处理父会话。
    * @param {'window-start'|'manual'} cause
    */
-  async function pauseRunning(cause) {
+  async function pauseRunning(cause, onlySessionId) {
     if (busy.pause) return [];
     busy.pause = true;
     try {
@@ -443,6 +450,7 @@ export function createGuard(ctx, config = {}) {
       const handled = [];
       let changed = false;
       for (const agent of liveAgents()) {
+        if (onlySessionId !== undefined && agent.id !== onlySessionId) continue;
         if (agent.status !== 'running') continue;
         const session = guardableSession(agent);
         if (session === null) continue;
@@ -629,17 +637,40 @@ export function createGuard(ctx, config = {}) {
     }
   }
 
-  /** 到谷价时段后执行排定的工作。 */
-  async function runDuePlans() {
+  /** 到谷价时段后执行排定的工作；ownerSessionId 用于工具只执行当前会话的规划。 */
+  async function runDuePlans(ownerSessionId) {
     if (busy.plans) return [];
     busy.plans = true;
     try {
       const state = await readState();
-      const due = state.plans.filter((item) => item.status === 'queued');
+      const due = state.plans.filter(
+        (item) =>
+          item.status === 'queued' &&
+          (ownerSessionId === undefined || item.createdBySessionId === ownerSessionId),
+      );
       if (due.length === 0) return [];
       const executed = [];
       for (const plan of due) {
+        // 只执行创建者与目标一致的规划；旧版本没有创建者的规划无法证明
+        // 是当前会话排定的，直接隔离，避免被当成跨会话投递通道。
+        if (
+          typeof plan.createdBySessionId !== 'string' ||
+          plan.createdBySessionId === '' ||
+          plan.createdBySessionId !== plan.sessionId
+        ) {
+          plan.status = 'failed';
+          plan.failedAt = Date.now();
+          plan.error = '旧版或跨会话规划没有明确授权，已停用；请从目标会话重新排定';
+          continue;
+        }
         if (typeof plan.prompt === 'string' && plan.prompt.trim() !== '') {
+          const target = service('sessions')?.get?.(plan.sessionId);
+          if (target !== undefined && target !== null && target.header?.parentSession !== undefined) {
+            plan.status = 'failed';
+            plan.failedAt = Date.now();
+            plan.error = '规划目标不是根会话，已停用';
+            continue;
+          }
           try {
             await promptSession(plan.sessionId, planText(plan));
             plan.status = 'done';
@@ -925,8 +956,8 @@ export function createGuard(ctx, config = {}) {
     return { desc, state, snapshot: await snapshotOf(desc, state) };
   }
 
-  async function pauseNow() {
-    const paused = await pauseRunning('manual');
+  async function pauseNow(sessionId) {
+    const paused = await pauseRunning('manual', sessionId);
     await status();
     return paused;
   }
@@ -941,16 +972,18 @@ export function createGuard(ctx, config = {}) {
     const title = typeof input.title === 'string' ? input.title.trim() : '';
     const prompt = typeof input.prompt === 'string' ? input.prompt.trim() : '';
     if (title === '' && prompt === '') throw new Error('规划至少要有 title 或 prompt');
-    const state = await readState();
-    const sessionId = typeof input.sessionId === 'string' && input.sessionId.trim() !== '' ? input.sessionId.trim() : input.fallbackSessionId;
-    if (typeof sessionId !== 'string' || sessionId === '') {
-      throw new Error('无法确定要执行的会话：请在已知会话里调用，或显式传 sessionId');
+    const owner = typeof input.createdBySessionId === 'string' ? input.createdBySessionId.trim() : '';
+    const requested = typeof input.sessionId === 'string' && input.sessionId.trim() !== '' ? input.sessionId.trim() : '';
+    if (owner === '' || requested === '' || requested !== owner) {
+      throw new Error('规划只能排给调用它的当前会话');
     }
+    const state = await readState();
     const plan = {
       id: shortId('plan'),
       title: title === '' ? prompt.slice(0, 40) : title,
       prompt,
-      sessionId,
+      sessionId: owner,
+      createdBySessionId: owner,
       createdAt: Date.now(),
       status: 'queued',
       runAt: 'next-offpeak',
@@ -961,27 +994,39 @@ export function createGuard(ctx, config = {}) {
     return plan;
   }
 
-  async function removePlan(id) {
+  async function removePlan(id, ownerSessionId) {
+    if (typeof ownerSessionId !== 'string' || ownerSessionId === '') return false;
     const state = await readState();
-    const before = state.plans.length;
+    const plan = state.plans.find((item) => item.id === id);
+    const owned =
+      plan !== undefined &&
+      (plan.createdBySessionId === ownerSessionId ||
+        ((plan.createdBySessionId === undefined || plan.createdBySessionId === null) &&
+          plan.sessionId === ownerSessionId));
+    if (!owned) return false;
     state.plans = state.plans.filter((item) => item.id !== id);
-    const removed = before !== state.plans.length;
-    if (removed) await stateFile.write(state);
+    await stateFile.write(state);
     await status();
-    return removed;
+    return true;
   }
 
-  async function clearPlans() {
+  async function clearPlans(ownerSessionId) {
+    if (typeof ownerSessionId !== 'string' || ownerSessionId === '') return 0;
     const state = await readState();
-    const removed = state.plans.filter((item) => item.status === 'queued').length;
-    state.plans = state.plans.filter((item) => item.status !== 'queued');
+    const owned = (item) =>
+      item.createdBySessionId === ownerSessionId ||
+      ((item.createdBySessionId === undefined || item.createdBySessionId === null) &&
+        item.sessionId === ownerSessionId);
+    const removed = state.plans.filter((item) => item.status === 'queued' && owned(item)).length;
+    state.plans = state.plans.filter((item) => !(item.status === 'queued' && owned(item)));
     await stateFile.write(state);
     await status();
     return removed;
   }
 
-  async function runPlansNow() {
-    const executed = await runDuePlans();
+  async function runPlansNow(ownerSessionId) {
+    if (typeof ownerSessionId !== 'string' || ownerSessionId === '') return [];
+    const executed = await runDuePlans(ownerSessionId);
     await status();
     return executed;
   }
@@ -1036,6 +1081,7 @@ export function createGuard(ctx, config = {}) {
     removePlan,
     clearPlans,
     runPlansNow,
+    runDuePlans,
     setExempt,
     setModelRule,
     setPauseMode,

package/lib/tools.js

@@ -19,6 +19,86 @@ const OUTPUT = {
 
 const result = (text, data = {}) => ({ text, data });
 
+/** 工具只能在真实会话内调用；返回调用者自己的 session id。 */
+function callerSessionId(exec) {
+  const id = exec?.agent?.id;
+  if (typeof id !== 'string' || id === '') {
+    throw new Error('该操作只能在会话内调用，无法确定当前会话');
+  }
+  return id;
+}
+
+/** 会话级操作默认且只允许作用于当前会话；显式传其它 sessionId 直接拒绝。 */
+function ownSessionId(exec, requested) {
+  const own = callerSessionId(exec);
+  const target = typeof requested === 'string' && requested.trim() !== '' ? requested.trim() : own;
+  if (target !== own) {
+    throw new Error('只能操作当前会话；跨会话请从目标会话调用，或使用设置面板由用户操作');
+  }
+  return own;
+}
+
+/** 快照里的规划按创建者过滤，避免工具读取/管理其它会话的规划。 */
+function ownPlanSnapshot(snapshot, owner) {
+  const plans = (Array.isArray(snapshot.plans) ? snapshot.plans : []).filter(
+    (item) =>
+      item.createdBySessionId === owner ||
+      ((item.createdBySessionId === null || item.createdBySessionId === undefined) &&
+        item.sessionId === owner),
+  );
+  return {
+    ...snapshot,
+    plans,
+    counts: { ...(snapshot.counts ?? {}), plans: plans.length },
+  };
+}
+
+/** 状态工具只返回当前会话的暂停/豁免/规划明细；规则与倒计时保持全局。 */
+function ownStatusSnapshot(snapshot, owner) {
+  const interrupted = (Array.isArray(snapshot.interrupted) ? snapshot.interrupted : []).filter(
+    (item) => item.sessionId === owner,
+  );
+  const exemptSessions = (Array.isArray(snapshot.exemptSessions) ? snapshot.exemptSessions : []).filter(
+    (item) => item.sessionId === owner,
+  );
+  const plans = (Array.isArray(snapshot.plans) ? snapshot.plans : []).filter(
+    (item) =>
+      item.createdBySessionId === owner ||
+      ((item.createdBySessionId === null || item.createdBySessionId === undefined) &&
+        item.sessionId === owner),
+  );
+  const ownSession =
+    snapshot.sessions !== null && typeof snapshot.sessions === 'object' ? snapshot.sessions[owner] : undefined;
+  const sessions = ownSession !== undefined ? { [owner]: ownSession } : {};
+  const model =
+    ownSession !== undefined
+      ? {
+          id: ownSession.id,
+          provider: ownSession.provider,
+          label: ownSession.id,
+          peakPriced: ownSession.peakPriced === true,
+        }
+      : snapshot.model;
+  return {
+    ...snapshot,
+    model,
+    interrupted,
+    exemptSessions,
+    plans,
+    sessions,
+    counts: {
+      ...(snapshot.counts ?? {}),
+      interrupted: interrupted.filter((item) => item.status === 'paused').length,
+      waiting: interrupted.filter(
+        (item) => item.status === 'waiting-turn' || item.status === 'waiting-children',
+      ).length,
+      exempt: exemptSessions.length,
+      plans: plans.length,
+    },
+  };
+}
+
+
 function timeLine(desc) {
   return `现在：${desc.localTime} ${desc.weekday}（${desc.timezone}）`;
 }
@@ -135,40 +215,50 @@ export function createOffpeakTools(guard) {
       name: 'offpeak_status',
       description:
         '查看 DeepSeek 峰谷计价状态：现在处于峰值原价还是谷价时段、距下次切换多久、当前会话使用的模型是否适用峰谷计价，' +
-        '以及守卫暂停了哪些任务、排定了哪些错峰规划。要在动手前判断「现在做这件事是否贵」，或想确认插件是否在工作时用它。',
+        '以及当前会话被暂停了哪些任务、排定了哪些错峰规划。要在动手前判断「现在做这件事是否贵」，或想确认插件是否在工作时用它。' +
+        '会话明细只返回当前会话，其它会话请在界面查看。',
       parameters: { type: 'object', properties: {}, additionalProperties: false },
       output: OUTPUT,
-      async execute() {
+      async execute(_args, exec) {
+        const owner = callerSessionId(exec);
         const { desc, snapshot } = await guard.status();
-        return result(statusText(desc, snapshot), snapshot);
+        const mine = ownStatusSnapshot(snapshot, owner);
+        return result(statusText(desc, mine), mine);
       },
     },
     {
       name: 'offpeak_plan',
       description:
-        '错峰工作规划：把一件稍后再做的事排进队列，峰时排定、谷价时段自动执行（会向排定它的会话发一条继续指令）。' +
+        '错峰工作规划：把一件稍后再做的事排进队列，峰时排定、谷价时段自动执行（只会向调用本工具的当前会话发一条继续指令）。' +
         'action=add 需要 title 或 prompt；action=list 查看；action=remove 需要 id；action=clear 清空未执行的规划。' +
-        '适合「现在峰时，别开长任务，等 12:00 谷价再跑」这类安排。',
+        '所有操作只作用于当前会话，显式传其它 sessionId 会被拒绝；适合「现在峰时，别开长任务，等 12:00 谷价再跑」这类安排。',
       parameters: {
         type: 'object',
         properties: {
           action: { type: 'string', enum: ['add', 'list', 'remove', 'clear'], description: '要执行的操作，默认 add' },
           title: { type: 'string', description: '规划名称（add 时建议填写）' },
-          prompt: { type: 'string', description: '到谷价时段要发给会话的完整指令（add 时可选；省略则只做提醒）' },
+          prompt: { type: 'string', description: '到谷价时段要发给当前会话的完整指令（add 时可选；省略则只做提醒）' },
           id: { type: 'string', description: 'remove 时要删除的规划 id' },
-          sessionId: { type: 'string', description: '执行该规划的会话 id；省略时用调用本工具的会话' },
+          sessionId: {
+            type: 'string',
+            description: '仅为兼容保留：只接受当前会话 id；省略即当前会话，传其它会话会被拒绝',
+          },
         },
         additionalProperties: false,
       },
       output: OUTPUT,
       async execute(args, exec) {
         const action = typeof args?.action === 'string' ? args.action : 'add';
+        const owner = callerSessionId(exec);
         if (action === 'add') {
+          if (typeof args?.sessionId === 'string' && args.sessionId.trim() !== '' && args.sessionId.trim() !== owner) {
+            throw new Error('只能为当前会话排定规划；跨会话请从目标会话调用');
+          }
           const plan = await guard.addPlan({
             title: args?.title,
             prompt: args?.prompt,
-            sessionId: args?.sessionId,
-            fallbackSessionId: exec?.agent?.id,
+            sessionId: owner,
+            createdBySessionId: owner,
           });
           const desc = guard.describe();
           const when = desc.phase === 'offpeak' ? `下一轮检查（约 ${Math.round(guard.options.pollMs / 1000)} 秒内）` : `${desc.next.label} 谷价开始后`;
@@ -179,40 +269,39 @@ export function createOffpeakTools(guard) {
         }
         if (action === 'remove') {
           if (typeof args?.id !== 'string' || args.id === '') throw new Error('remove 需要 id');
-          const removed = await guard.removePlan(args.id);
+          const removed = await guard.removePlan(args.id, owner);
           return result(removed ? `已删除规划 ${args.id}。` : `没有找到规划 ${args.id}。`, { removed, id: args.id });
         }
         if (action === 'clear') {
-          const removed = await guard.clearPlans();
+          const removed = await guard.clearPlans(owner);
           return result(`已清空 ${removed} 项未执行的规划。`, { removed });
         }
         const { desc, snapshot } = await guard.status();
-        return result(planLine(snapshot) + `\n${nextLine(desc)}`, snapshot);
+        const mine = ownPlanSnapshot(snapshot, owner);
+        return result(planLine(mine) + `\n${nextLine(desc)}`, {
+          plans: mine.plans,
+          counts: { plans: mine.plans.length },
+        });
       },
     },
     {
       name: 'offpeak_guard',
       description:
-        '峰谷守卫的手动控制：status 查看完整状态；pause_now 立刻按当前策略暂停峰谷计价任务（峰时才生效）；' +
-        'resume_now 立刻恢复被暂停的任务（谷价时才自动恢复，手动可在任何时段强制恢复）；run_plans_now 立刻执行排定的错峰规划；' +
-        'exempt / unexempt 让某个会话豁免/取消豁免；pauseMode 设置峰时是立即暂停还是完成当前轮后暂停。' +
-        '用户明确要求「先停一下 / 现在就恢复 / 这个会话别管」时使用。',
+        '峰谷守卫的手动控制：status 查看当前会话状态；pause_now 按当前策略暂停当前会话的峰谷计价任务（峰时才生效）；' +
+        'resume_now 立刻恢复当前会话被暂停的任务（谷价时才自动恢复，手动可在任何时段强制恢复）；run_plans_now 立刻执行当前会话排定的错峰规划；' +
+        'exempt / unexempt 让当前会话豁免/取消豁免。' +
+        '所有操作都只作用于调用本工具的当前会话；全局峰时策略请在设置面板由用户修改。',
       parameters: {
         type: 'object',
         properties: {
           action: {
             type: 'string',
-            enum: ['status', 'pause_now', 'resume_now', 'run_plans_now', 'exempt', 'unexempt', 'pause_mode'],
+            enum: ['status', 'pause_now', 'resume_now', 'run_plans_now', 'exempt', 'unexempt'],
             description: '要执行的操作，默认 status',
           },
           sessionId: {
             type: 'string',
-            description: 'resume_now 时只恢复这个会话；exempt/unexempt 时指定会话（省略用当前会话）',
-          },
-          mode: {
-            type: 'string',
-            enum: ['pause-now', 'finish-turn'],
-            description: 'pause_mode 时的策略：立即暂停或完成当前轮后暂停',
+            description: '仅为兼容保留：只接受当前会话 id；resume_now / exempt / unexempt 传其它会话会被拒绝',
           },
         },
         additionalProperties: false,
@@ -220,15 +309,17 @@ export function createOffpeakTools(guard) {
       output: OUTPUT,
       async execute(args, exec) {
         const action = typeof args?.action === 'string' ? args.action : 'status';
+        const owner = callerSessionId(exec);
         if (action === 'pause_now') {
-          const handled = await guard.pauseNow();
+          ownSessionId(exec, args?.sessionId);
+          const handled = await guard.pauseNow(owner);
           const paused = handled.filter((item) => item.status === 'paused');
           const waiting = handled.filter((item) => item.status === 'waiting-turn' || item.status === 'waiting-children');
           const names = handled.map((item) => item.title ?? item.sessionId).join('、');
           return result(
             handled.length === 0
-              ? '当前没有可暂停的任务（可能不在峰时，或任务模型不适用峰谷计价）。'
-              : `已处理 ${handled.length} 个任务：${names}。` +
+              ? '当前会话没有可暂停的任务（可能不在峰时，或任务模型不适用峰谷计价）。'
+              : `已处理当前会话的 ${handled.length} 个任务：${names}。` +
                   (paused.length > 0 ? ` 已暂停 ${paused.length} 个。` : '') +
                   (waiting.length > 0 ? ` ${waiting.length} 个等当前轮/子代理结束后暂停。` : '') +
                   ' 谷价开始后会自动恢复。',
@@ -236,18 +327,16 @@ export function createOffpeakTools(guard) {
           );
         }
         if (action === 'resume_now') {
-          const sessionId = typeof args?.sessionId === 'string' && args.sessionId !== '' ? args.sessionId : undefined;
-          const resumed = await guard.resumeNow(sessionId === undefined ? undefined : [sessionId]);
-          return result(resumed.length === 0 ? '没有需要恢复的任务。' : `已恢复 ${resumed.length} 个任务。`, { resumed });
+          ownSessionId(exec, args?.sessionId);
+          const resumed = await guard.resumeNow([owner]);
+          return result(resumed.length === 0 ? '当前会话没有需要恢复的任务。' : `已恢复 ${resumed.length} 个任务。`, { resumed });
         }
         if (action === 'run_plans_now') {
-          const executed = await guard.runPlansNow();
-          return result(executed.length === 0 ? '没有待执行的错峰规划。' : `已执行 ${executed.length} 项规划。`, { executed });
+          const executed = await guard.runPlansNow(owner);
+          return result(executed.length === 0 ? '当前会话没有待执行的错峰规划。' : `已执行 ${executed.length} 项规划。`, { executed });
         }
         if (action === 'exempt' || action === 'unexempt') {
-          const sessionId =
-            typeof args?.sessionId === 'string' && args.sessionId !== '' ? args.sessionId : exec?.agent?.id;
-          if (typeof sessionId !== 'string' || sessionId === '') throw new Error('需要 sessionId');
+          const sessionId = ownSessionId(exec, args?.sessionId);
           const resultState = await guard.setExempt(sessionId, action === 'exempt');
           return result(
             action === 'exempt' ? `已豁免会话 ${sessionId}，守卫不会再暂停它。` : `已取消会话 ${sessionId} 的豁免。`,
@@ -255,12 +344,11 @@ export function createOffpeakTools(guard) {
           );
         }
         if (action === 'pause_mode') {
-          const mode = args?.mode === 'finish-turn' ? 'finish-turn' : 'pause-now';
-          await guard.setPauseMode(mode);
-          return result(mode === 'finish-turn' ? '已设置为：完成当前轮后暂停。' : '已设置为：峰时立即暂停。', { mode });
+          throw new Error('pause_mode 只能由用户在设置面板修改，模型工具不提供全局策略修改');
         }
         const { desc, snapshot } = await guard.status();
-        return result(statusText(desc, snapshot), snapshot);
+        const mine = ownStatusSnapshot(snapshot, owner);
+        return result(statusText(desc, mine), mine);
       },
     },
   ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-offpeak-guard",
-  "version": "0.3.2",
+  "version": "0.3.4",
   "description": "DeepSeek peak/off-peak pricing guard for DSH: detects the price window and current model, pauses running tasks at peak, resumes them automatically when off-peak begins, and schedules work for the next off-peak window.",
   "private": false,
   "type": "module",