opencode-empirical-plan 0.3.2 → 0.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-empirical-plan",
-  "version": "0.3.2",
+  "version": "0.3.3",
   "description": "OpenCode lifecycle plugin for empirical plan orchestration.",
   "author": "chuck",
   "license": "MIT",

package/src/hooks/skill-reminder.ts

@@ -1,12 +1,14 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
 const KEY = Symbol.for("opencode-empirical-plan.skillReminder");
 
 interface SkillReminderStore {
-  armedSessions: Set<string>;
+  notifiedMessageIds: Map<string, number>;
 }
 
 if (!(globalThis as Record<symbol, unknown>)[KEY]) {
   (globalThis as Record<symbol, unknown>)[KEY] = {
-    armedSessions: new Set<string>(),
+    notifiedMessageIds: new Map<string, number>(),
   } satisfies SkillReminderStore;
 }
 
@@ -14,20 +16,32 @@ const store = (globalThis as Record<symbol, unknown>)[KEY] as SkillReminderStore
 
 const ENGLISH_KEYWORD_REGEX = /\b(plan|planning)\b/i;
 const CHINESE_KEYWORDS = ["计划", "规划", "制定计划", "做计划"];
+const MAX_DEDUP_ENTRIES = 200;
+
+const PLUGIN_VARIANT = "empirical-plan-reminder";
+const REMINDER_PREFIX = "## [Empirical Plan Reminder]";
+
+const REMINDER_TEXT = `## [Empirical Plan Reminder]
+
+检测到规划类关键词（plan / 计划 / 规划）。
+
+**在回答前，请先执行：**
+\`\`\`
+skill(name="empirical-plan")
+\`\`\`
+
+**重要**：执行 empirical-plan 时，必须通过 \`task()\` 启动独立子 session，禁止在当前 session 内联执行：
+\`\`\`
+task(load_skills=["empirical-plan"], run_in_background=false, prompt="使用 empirical-plan skill 完成 Phase 1-3，产出 plan.md。目标：<描述>")
+\`\`\`
+
+如果这只是一个澄清问题（非任务），或本 session 已加载过 empirical-plan，可跳过。`;
 
 interface TextPartLike {
   type?: string;
   text?: unknown;
 }
 
-function containsPlanningKeywords(text: string): boolean {
-  if (ENGLISH_KEYWORD_REGEX.test(text)) {
-    return true;
-  }
-
-  return CHINESE_KEYWORDS.some((keyword) => text.includes(keyword));
-}
-
 function extractText(parts: unknown[]): string {
   const texts: string[] = [];
   for (const part of parts) {
@@ -39,28 +53,72 @@ function extractText(parts: unknown[]): string {
   return texts.join("\n");
 }
 
+function containsPlanningKeywords(text: string): boolean {
+  if (ENGLISH_KEYWORD_REGEX.test(text)) return true;
+  return CHINESE_KEYWORDS.some((kw) => text.includes(kw));
+}
+
+function normalizeTextKey(text: string): string {
+  return text.trim().toLowerCase().replace(/\s+/g, " ");
+}
+
+function buildMessageKey(sessionID: string, messageID: string | undefined, text: string): string {
+  if (messageID) return `id:${sessionID}:${messageID}`;
+  return `text:${sessionID}:${normalizeTextKey(text)}`;
+}
+
+function markNotified(messageKey: string): void {
+  store.notifiedMessageIds.set(messageKey, Date.now());
+  while (store.notifiedMessageIds.size > MAX_DEDUP_ENTRIES) {
+    const oldestKey = store.notifiedMessageIds.keys().next().value;
+    if (!oldestKey) break;
+    store.notifiedMessageIds.delete(oldestKey);
+  }
+}
+
 export async function handleSkillReminderChatMessage(
   sessionID: string,
+  options: { variant?: string; messageID?: string; role?: string },
   parts: unknown[],
+  client: PluginInput["client"],
 ): Promise<void> {
+  let messageKey: string | undefined;
   try {
+    if (options.variant === PLUGIN_VARIANT) return;
+    if (options.role !== "user") return;
+
     const text = extractText(parts);
     if (!text) return;
+    if (text.trimStart().startsWith(REMINDER_PREFIX)) return;
     if (!containsPlanningKeywords(text)) return;
-    store.armedSessions.add(sessionID);
-  } catch (err) {
-    console.error("[empirical-plan] skill-reminder chat.message error:", err);
-  }
-}
+    messageKey = buildMessageKey(sessionID, options.messageID, text);
+    if (store.notifiedMessageIds.has(messageKey)) return;
 
-export function consumeSkillReminderArmed(sessionID: string): boolean {
-  if (!store.armedSessions.has(sessionID)) {
-    return false;
+    markNotified(messageKey);
+
+    await client.session.prompt({
+      path: { id: sessionID },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text: REMINDER_TEXT }],
+      },
+    });
+  } catch (err) {
+    console.error("[empirical-plan] skill-reminder error:", err);
+    if (messageKey) {
+      store.notifiedMessageIds.delete(messageKey);
+    }
   }
-  store.armedSessions.delete(sessionID);
-  return true;
 }
 
 export function cleanupSkillReminderSession(sessionID: string): void {
-  store.armedSessions.delete(sessionID);
+  const keysToDelete: string[] = [];
+  for (const key of store.notifiedMessageIds.keys()) {
+    if (key.includes(`:${sessionID}:`)) {
+      keysToDelete.push(key);
+    }
+  }
+  for (const key of keysToDelete) {
+    store.notifiedMessageIds.delete(key);
+  }
 }

package/src/index.ts

@@ -7,7 +7,6 @@ import { recordCallStart } from "./hooks/tool-before.ts";
 import { handleSessionIdle } from "./hooks/session-idle.ts";
 import { cleanup, cleanupChild } from "./state/active-lifecycles.ts";
 import { handleSkillReminderChatMessage, cleanupSkillReminderSession } from "./hooks/skill-reminder.ts";
-import { handleSystemTransform } from "./hooks/system-transform.ts";
 
 export const EmpiricalPlanPlugin: Plugin = async ({ client }) => {
   return {
@@ -19,16 +18,17 @@ export const EmpiricalPlanPlugin: Plugin = async ({ client }) => {
 
     "chat.message": async (input, output) => {
       try {
-        await handleSkillReminderChatMessage(input.sessionID, output.parts);
+        await handleSkillReminderChatMessage(
+          input.sessionID,
+          { variant: input.variant, messageID: input.messageID, role: output.message?.role },
+          output.parts,
+          client,
+        );
       } catch (err) {
         console.error("[empirical-plan] chat.message error:", err);
       }
     },
 
-    "experimental.chat.system.transform": async (input, output) => {
-      await handleSystemTransform(input.sessionID, output.system);
-    },
-
     "tool.execute.before": async (input) => {
       try {
         recordCallStart(input.callID);

package/src/hooks/system-transform.ts

@@ -1,21 +0,0 @@
-import { consumeSkillReminderArmed } from "./skill-reminder.ts";
-
-const SKILL_REMINDER_TEXT = `<skill-reminder>
-User message contains planning-related keywords. BEFORE responding:
-1. Call skill(name="empirical-plan") to load the full planning workflow
-2. Only skip if: this is a clarification question (not a task), or empirical-plan is already loaded this session
-</skill-reminder>`;
-
-export async function handleSystemTransform(
-  sessionID: string | undefined,
-  system: string[],
-): Promise<void> {
-  try {
-    if (!sessionID) return;
-    const armed = consumeSkillReminderArmed(sessionID);
-    if (!armed) return;
-    system.push(SKILL_REMINDER_TEXT);
-  } catch (err) {
-    console.error("[empirical-plan] system-transform error:", err);
-  }
-}