stackmem 1.0.13 → 1.0.15

package/src/cli.ts

@@ -282,11 +282,31 @@ async function cmdStart(project: string) {
 
   const budgetedMemories = applyContextBudget(scoredMemories, CONTEXT_BUDGET_TOKENS);
   const omittedCount = scoredMemories.length - budgetedMemories.length;
-  const tokensUsed = budgetedMemories.reduce(
+  let tokensUsed = budgetedMemories.reduce(
     (sum, memory) => sum + estimateTokens(memory.content),
     0
   );
 
+  const { data: fixData, error: fixError } = await supabase
+    .from("execution_log")
+    .select("*")
+    .eq("project", project)
+    .eq("resolved", false)
+    .order("created_at", { ascending: false })
+    .limit(5);
+
+  if (fixError) fail(`Failed to load execution log: ${fixError.message}`);
+
+  // Fixes share the same 2000-token budget as memories, which already
+  // consumed their portion above — fixes only get whatever room is left.
+  const budgetedFixes: { problem: string; solution: string | null }[] = [];
+  for (const fix of fixData ?? []) {
+    const tokens = estimateTokens(`${fix.problem} ${fix.solution ?? ""}`);
+    if (tokensUsed + tokens > CONTEXT_BUDGET_TOKENS) break;
+    budgetedFixes.push(fix);
+    tokensUsed += tokens;
+  }
+
   const memoryIds = budgetedMemories.map((m) => m.id);
   const linkedIdsByMemory = new Map<string, Set<string>>();
 
@@ -323,6 +343,16 @@ async function cmdStart(project: string) {
     console.log("");
   }
 
+  if (budgetedFixes.length > 0) {
+    console.log(`Past Fixes (${budgetedFixes.length})`);
+    console.log("-".repeat(14));
+    for (const fix of budgetedFixes) {
+      console.log(`  Problem: ${fix.problem}`);
+      console.log(`  Solution: ${fix.solution ?? "(pending)"}`);
+      console.log("");
+    }
+  }
+
   console.log(`Context budget: ${tokensUsed}/${CONTEXT_BUDGET_TOKENS} tokens used`);
   if (omittedCount > 0) {
     console.log(`${omittedCount} memories omitted (budget exceeded)`);

package/src/index.ts

@@ -92,6 +92,23 @@ server.registerTool(
       linked_memory_ids: Array.from(linkedIdsByMemory.get(m.id) ?? []),
     }));
 
+    const { data: fixData, error: fixError } = await supabase
+      .from("execution_log")
+      .select("*")
+      .eq("project", project)
+      .eq("resolved", false)
+      .order("created_at", { ascending: false })
+      .limit(5);
+
+    if (fixError) {
+      throw new Error(`Failed to load execution log: ${fixError.message}`);
+    }
+
+    const fixes = (fixData ?? []).map((fix) => ({
+      problem: fix.problem,
+      solution: fix.solution ?? "pending",
+    }));
+
     if (budgetedMemories.length > 0) {
       const incrementResults = await Promise.all(
         budgetedMemories.map((memory) =>
@@ -116,6 +133,7 @@ server.registerTool(
       content: [{ type: "text", text: budgetText }],
       structuredContent: {
         memories: memoriesWithLinks,
+        fixes,
         context_budget: {
           budget_tokens: CONTEXT_BUDGET_TOKENS,
           tokens_used: tokensUsed,

package/src/scoring.ts

@@ -79,6 +79,12 @@ function containsNegationWord(text: string): boolean {
   return NEGATION_WORDS.some((word) => lower.includes(word));
 }
 
+// Hook-generated dependency-change templates (e.g. "removed dependency: X")
+// are structural facts, not decisions — "removed" trips the negation-word
+// check below, but there's nothing for them to supersede/contradict, so
+// they're exempted up front rather than ever entering the negation branch.
+const DEPENDENCY_TEMPLATE_RE = /^(removed|added) dependency:/i;
+
 export type SaveAction =
   | { action: "duplicate"; matchedId: string }
   | { action: "superseded"; oldId: string }
@@ -97,7 +103,7 @@ export function decideSaveAction(
   existingMemories: ExistingMemory[]
 ): SaveAction {
   const newEntities = extractEntities(newContent);
-  const hasNegation = containsNegationWord(newContent);
+  const hasNegation = DEPENDENCY_TEMPLATE_RE.test(newContent) ? false : containsNegationWord(newContent);
 
   let bestDuplicate: { id: string; score: number } | null = null;
   let bestSupersede: { id: string; score: number } | null = null;