opencode-empirical-plan 0.3.1 → 0.3.2

package/package.json

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

package/src/hooks/skill-reminder.ts

@@ -0,0 +1,66 @@
+const KEY = Symbol.for("opencode-empirical-plan.skillReminder");
+
+interface SkillReminderStore {
+  armedSessions: Set<string>;
+}
+
+if (!(globalThis as Record<symbol, unknown>)[KEY]) {
+  (globalThis as Record<symbol, unknown>)[KEY] = {
+    armedSessions: new Set<string>(),
+  } satisfies SkillReminderStore;
+}
+
+const store = (globalThis as Record<symbol, unknown>)[KEY] as SkillReminderStore;
+
+const ENGLISH_KEYWORD_REGEX = /\b(plan|planning)\b/i;
+const CHINESE_KEYWORDS = ["计划", "规划", "制定计划", "做计划"];
+
+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) {
+    const candidate = part as TextPartLike;
+    if (candidate.type === "text" && typeof candidate.text === "string") {
+      texts.push(candidate.text);
+    }
+  }
+  return texts.join("\n");
+}
+
+export async function handleSkillReminderChatMessage(
+  sessionID: string,
+  parts: unknown[],
+): Promise<void> {
+  try {
+    const text = extractText(parts);
+    if (!text) return;
+    if (!containsPlanningKeywords(text)) return;
+    store.armedSessions.add(sessionID);
+  } catch (err) {
+    console.error("[empirical-plan] skill-reminder chat.message error:", err);
+  }
+}
+
+export function consumeSkillReminderArmed(sessionID: string): boolean {
+  if (!store.armedSessions.has(sessionID)) {
+    return false;
+  }
+  store.armedSessions.delete(sessionID);
+  return true;
+}
+
+export function cleanupSkillReminderSession(sessionID: string): void {
+  store.armedSessions.delete(sessionID);
+}

package/src/hooks/system-transform.ts

@@ -0,0 +1,21 @@
+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);
+  }
+}

package/src/index.ts

@@ -6,6 +6,8 @@ import { handleToolAfter } from "./hooks/tool-after.ts";
 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 {
@@ -15,6 +17,18 @@ export const EmpiricalPlanPlugin: Plugin = async ({ client }) => {
       lifecycle_record_reflection: lifecycleRecordReflectionTool,
     },
 
+    "chat.message": async (input, output) => {
+      try {
+        await handleSkillReminderChatMessage(input.sessionID, output.parts);
+      } 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);
@@ -49,6 +63,7 @@ export const EmpiricalPlanPlugin: Plugin = async ({ client }) => {
           if (sessionID) {
             cleanup(sessionID);
             cleanupChild(sessionID);
+            cleanupSkillReminderSession(sessionID);
           }
         }
       } catch (err) {

package/src/tools/lifecycle-start.ts

@@ -58,7 +58,7 @@ advances lifecycle-state.json to the next phase (plan→execute→reflect→done
           next_action: "Wait for the current lifecycle to complete before starting a new one.",
         });
       }
-      console.log(`[empirical-plan] lifecycle_start: stale map entry for session ${ctx.sessionID} (phase=${existingState?.phase ?? "missing"}), proceeding with new lifecycle`);
+
     }
 
     await fs.mkdir(runDir, { recursive: true });