@opencode_weave/weave 0.4.1 → 0.4.2

package/dist/hooks/index.d.ts

@@ -10,3 +10,5 @@ export { detectKeywords, buildKeywordInjection, processMessageForKeywords, DEFAU
 export type { KeywordAction } from "./keyword-detector";
 export { buildVerificationReminder } from "./verification-reminder";
 export type { VerificationInput, VerificationResult } from "./verification-reminder";
+export { setContextLimit, updateUsage, getState, clearSession as clearTokenSession, clear as clearAllTokenState, } from "./session-token-state";
+export type { SessionTokenEntry } from "./session-token-state";

package/dist/hooks/session-token-state.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Per-session token state tracker.
+ *
+ * Bridges the gap between:
+ * - `chat.params` hook → provides model context limit (maxTokens)
+ * - `message.updated` event → provides latest input token usage (usedTokens)
+ *
+ * Uses an in-memory Map keyed by sessionId. State resets on plugin restart,
+ * which is acceptable — data rebuilds on the next `chat.params` + `message.updated` pair.
+ */
+export interface SessionTokenEntry {
+    maxTokens: number;
+    usedTokens: number;
+}
+/**
+ * Store the model's context limit for a session.
+ * Called from the `chat.params` hook when a session starts.
+ * Does NOT overwrite existing `usedTokens`.
+ */
+export declare function setContextLimit(sessionId: string, maxTokens: number): void;
+/**
+ * Update the latest input token usage for a session.
+ * Called from `message.updated` events with AssistantMessage tokens.
+ * Stores the latest value — NOT cumulative across messages.
+ * Does NOT overwrite existing `maxTokens`.
+ * Only updates when inputTokens > 0 (guards against partial streaming updates).
+ */
+export declare function updateUsage(sessionId: string, inputTokens: number): void;
+/**
+ * Get the current token state for a session.
+ * Returns undefined if the session is unknown.
+ */
+export declare function getState(sessionId: string): SessionTokenEntry | undefined;
+/**
+ * Remove a session from the tracker.
+ * Called on `session.deleted` events.
+ */
+export declare function clearSession(sessionId: string): void;
+/**
+ * Clear all session state. Used in tests only.
+ */
+export declare function clear(): void;

package/dist/index.js

@@ -563,7 +563,9 @@ For complex tasks that benefit from structured planning before execution:
 1. PLAN: Delegate to Pattern to produce a plan saved to \`.weave/plans/{name}.md\`
    - Pattern researches the codebase, produces a structured plan with \`- [ ]\` checkboxes
    - Pattern ONLY writes .md files in .weave/ — it never writes code
-2. REVIEW (optional): For complex plans, delegate to Weft to validate the plan before execution
+2. REVIEW: Delegate to Weft to validate the plan before execution
+   - TRIGGER: Plan touches 3+ files OR has 5+ tasks — Weft review is mandatory
+   - SKIP ONLY IF: User explicitly says "skip review"
    - Weft reads the plan, verifies file references, checks executability
    - If Weft rejects, send issues back to Pattern for revision
 3. EXECUTE: Tell the user to run \`/start-work\` to begin execution
@@ -2074,12 +2076,12 @@ Only mark complete when ALL checks pass.`
 
 // src/hooks/create-hooks.ts
 function createHooks(args) {
-  const { isHookEnabled, directory } = args;
+  const { pluginConfig, isHookEnabled, directory } = args;
   const writeGuardState = createWriteGuardState();
   const writeGuard = createWriteGuard(writeGuardState);
   const contextWindowThresholds = {
-    warningPct: 0.8,
-    criticalPct: 0.95
+    warningPct: pluginConfig.experimental?.context_window_warning_threshold ?? 0.8,
+    criticalPct: pluginConfig.experimental?.context_window_critical_threshold ?? 0.95
   };
   return {
     checkContextWindow: isHookEnabled("context-window-monitor") ? (state) => checkContextWindow(state, contextWindowThresholds) : null,
@@ -2094,7 +2096,30 @@ function createHooks(args) {
     verificationReminder: isHookEnabled("verification-reminder") ? buildVerificationReminder : null
   };
 }
-
+// src/hooks/session-token-state.ts
+var sessionMap = new Map;
+function setContextLimit(sessionId, maxTokens) {
+  const existing = sessionMap.get(sessionId);
+  sessionMap.set(sessionId, {
+    usedTokens: existing?.usedTokens ?? 0,
+    maxTokens
+  });
+}
+function updateUsage(sessionId, inputTokens) {
+  if (inputTokens <= 0)
+    return;
+  const existing = sessionMap.get(sessionId);
+  sessionMap.set(sessionId, {
+    maxTokens: existing?.maxTokens ?? 0,
+    usedTokens: inputTokens
+  });
+}
+function getState(sessionId) {
+  return sessionMap.get(sessionId);
+}
+function clearSession2(sessionId) {
+  sessionMap.delete(sessionId);
+}
 // src/plugin/plugin-interface.ts
 function createPluginInterface(args) {
   const { pluginConfig, hooks, tools, configHandler, agents, client } = args;
@@ -2114,13 +2139,6 @@ function createPluginInterface(args) {
     },
     "chat.message": async (input, _output) => {
       const { sessionID } = input;
-      if (hooks.checkContextWindow) {
-        hooks.checkContextWindow({
-          usedTokens: 0,
-          maxTokens: 0,
-          sessionId: sessionID
-        });
-      }
       if (hooks.firstMessageVariant) {
         if (hooks.firstMessageVariant.shouldApplyVariant(sessionID)) {
           hooks.firstMessageVariant.markApplied(sessionID);
@@ -2159,7 +2177,15 @@ ${result.contextInjection}`;
         }
       }
     },
-    "chat.params": async (_input, _output) => {},
+    "chat.params": async (_input, _output) => {
+      const input = _input;
+      const sessionId = input.sessionID ?? "";
+      const maxTokens = input.model?.limit?.context ?? 0;
+      if (sessionId && maxTokens > 0) {
+        setContextLimit(sessionId, maxTokens);
+        log("[context-window] Captured context limit", { sessionId, maxTokens });
+      }
+    },
     "chat.headers": async (_input, _output) => {},
     event: async (input) => {
       const { event } = input;
@@ -2173,6 +2199,35 @@ ${result.contextInjection}`;
           hooks.firstMessageVariant.clearSession(evt.properties.info.id);
         }
       }
+      if (event.type === "session.deleted") {
+        const evt = event;
+        clearSession2(evt.properties.info.id);
+      }
+      if (event.type === "message.updated" && hooks.checkContextWindow) {
+        const evt = event;
+        const info = evt.properties?.info;
+        if (info?.role === "assistant" && info.sessionID) {
+          const inputTokens = info.tokens?.input ?? 0;
+          if (inputTokens > 0) {
+            updateUsage(info.sessionID, inputTokens);
+            const tokenState = getState(info.sessionID);
+            if (tokenState && tokenState.maxTokens > 0) {
+              const result = hooks.checkContextWindow({
+                usedTokens: tokenState.usedTokens,
+                maxTokens: tokenState.maxTokens,
+                sessionId: info.sessionID
+              });
+              if (result.action !== "none") {
+                log("[context-window] Threshold crossed", {
+                  sessionId: info.sessionID,
+                  action: result.action,
+                  usagePct: result.usagePct
+                });
+              }
+            }
+          }
+        }
+      }
       if (hooks.workContinuation && event.type === "session.idle") {
         const evt = event;
         const sessionId = evt.properties?.sessionID ?? "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencode_weave/weave",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Weave — lean OpenCode plugin with multi-agent orchestration",
   "author": "Weave",
   "license": "MIT",