@blockrun/franklin 3.3.2 → 3.5.0

package/dist/brain/index.d.ts

@@ -0,0 +1,3 @@
+export type { Entity, EntityType, Observation, Relation, BrainExtraction } from './types.js';
+export { loadEntities, saveEntities, findEntity, upsertEntity, loadObservations, getEntityObservations, addObservation, loadRelations, getEntityRelations, upsertRelation, searchEntities, buildEntityContext, getBrainStats, } from './store.js';
+export { extractBrainEntities } from './extract.js';

package/dist/brain/index.js

@@ -0,0 +1,2 @@
+export { loadEntities, saveEntities, findEntity, upsertEntity, loadObservations, getEntityObservations, addObservation, loadRelations, getEntityRelations, upsertRelation, searchEntities, buildEntityContext, getBrainStats, } from './store.js';
+export { extractBrainEntities } from './extract.js';

package/dist/brain/store.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Franklin Brain — JSONL storage for entities, observations, relations.
+ * All in-memory with JSONL persistence. No database.
+ */
+import type { Entity, EntityType, Observation, Relation } from './types.js';
+export declare function loadEntities(): Entity[];
+export declare function saveEntities(entities: Entity[]): void;
+/**
+ * Find entity by name or alias (case-insensitive).
+ */
+export declare function findEntity(entities: Entity[], nameOrAlias: string): Entity | undefined;
+/**
+ * Create or update an entity. Returns the entity ID.
+ * If an entity with a matching name/alias exists, merges aliases and bumps reference_count.
+ */
+export declare function upsertEntity(entities: Entity[], name: string, type: EntityType, aliases?: string[]): string;
+export declare function loadObservations(): Observation[];
+export declare function getEntityObservations(entityId: string): Observation[];
+/**
+ * Add an observation. Deduplicates by content similarity (exact match).
+ */
+export declare function addObservation(entityId: string, content: string, source: string, confidence?: number, tags?: string[]): void;
+export declare function loadRelations(): Relation[];
+export declare function getEntityRelations(entityId: string): Relation[];
+/**
+ * Add or update a relation. If same from+to+type exists, bumps count.
+ */
+export declare function upsertRelation(fromId: string, toId: string, type: string, confidence?: number): void;
+/**
+ * Search entities by name/alias substring match.
+ */
+export declare function searchEntities(query: string, limit?: number): Entity[];
+/**
+ * Build context string for entities mentioned in the conversation.
+ * Returns empty string if no relevant entities found.
+ */
+export declare function buildEntityContext(mentionedNames: string[]): string;
+export declare function getBrainStats(): {
+    entities: number;
+    observations: number;
+    relations: number;
+};

package/dist/brain/store.js

@@ -0,0 +1,225 @@
+/**
+ * Franklin Brain — JSONL storage for entities, observations, relations.
+ * All in-memory with JSONL persistence. No database.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import crypto from 'node:crypto';
+import { BLOCKRUN_DIR } from '../config.js';
+const BRAIN_DIR = path.join(BLOCKRUN_DIR, 'brain');
+const ENTITIES_FILE = path.join(BRAIN_DIR, 'entities.jsonl');
+const OBSERVATIONS_FILE = path.join(BRAIN_DIR, 'observations.jsonl');
+const RELATIONS_FILE = path.join(BRAIN_DIR, 'relations.jsonl');
+const MAX_ENTITIES = 200;
+function uid() { return crypto.randomBytes(8).toString('hex'); }
+function ensureDir() {
+    fs.mkdirSync(BRAIN_DIR, { recursive: true });
+}
+// ─── Generic JSONL helpers ────────────────────────────────────────────────
+function loadJsonl(file) {
+    try {
+        const raw = fs.readFileSync(file, 'utf-8');
+        const results = [];
+        for (const line of raw.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                results.push(JSON.parse(line));
+            }
+            catch { /* skip corrupt */ }
+        }
+        return results;
+    }
+    catch {
+        return [];
+    }
+}
+function saveJsonl(file, items) {
+    ensureDir();
+    const tmp = file + '.tmp';
+    fs.writeFileSync(tmp, items.map(i => JSON.stringify(i)).join('\n') + '\n');
+    fs.renameSync(tmp, file);
+}
+function appendJsonl(file, item) {
+    ensureDir();
+    fs.appendFileSync(file, JSON.stringify(item) + '\n');
+}
+// ─── Entities ─────────────────────────────────────────────────────────────
+export function loadEntities() {
+    return loadJsonl(ENTITIES_FILE);
+}
+export function saveEntities(entities) {
+    saveJsonl(ENTITIES_FILE, entities);
+}
+/**
+ * Find entity by name or alias (case-insensitive).
+ */
+export function findEntity(entities, nameOrAlias) {
+    const lower = nameOrAlias.toLowerCase().trim();
+    return entities.find(e => e.name.toLowerCase() === lower ||
+        e.aliases.some(a => a.toLowerCase() === lower));
+}
+/**
+ * Create or update an entity. Returns the entity ID.
+ * If an entity with a matching name/alias exists, merges aliases and bumps reference_count.
+ */
+export function upsertEntity(entities, name, type, aliases = []) {
+    const existing = findEntity(entities, name) ||
+        aliases.map(a => findEntity(entities, a)).find(Boolean);
+    if (existing) {
+        // Merge aliases
+        const allAliases = new Set([...existing.aliases, ...aliases, name]);
+        allAliases.delete(existing.name); // Don't alias canonical name
+        existing.aliases = [...allAliases];
+        existing.reference_count++;
+        existing.updated_at = Date.now();
+        return existing.id;
+    }
+    // New entity
+    const entity = {
+        id: uid(),
+        type,
+        name,
+        aliases: aliases.filter(a => a.toLowerCase() !== name.toLowerCase()),
+        created_at: Date.now(),
+        updated_at: Date.now(),
+        reference_count: 1,
+    };
+    entities.push(entity);
+    // Cap at MAX_ENTITIES — prune least-referenced
+    if (entities.length > MAX_ENTITIES) {
+        entities.sort((a, b) => b.reference_count - a.reference_count);
+        entities.length = MAX_ENTITIES;
+    }
+    return entity.id;
+}
+// ─── Observations ─────────────────────────────────────────────────────────
+export function loadObservations() {
+    return loadJsonl(OBSERVATIONS_FILE);
+}
+export function getEntityObservations(entityId) {
+    return loadObservations().filter(o => o.entity_id === entityId);
+}
+/**
+ * Add an observation. Deduplicates by content similarity (exact match).
+ */
+export function addObservation(entityId, content, source, confidence = 0.8, tags = ['fact']) {
+    const existing = loadObservations();
+    const contentLower = content.toLowerCase().trim();
+    // Skip exact duplicates for this entity
+    if (existing.some(o => o.entity_id === entityId && o.content.toLowerCase().trim() === contentLower)) {
+        return;
+    }
+    appendJsonl(OBSERVATIONS_FILE, {
+        id: uid(),
+        entity_id: entityId,
+        content,
+        source,
+        confidence,
+        tags,
+        created_at: Date.now(),
+    });
+}
+// ─── Relations ────────────────────────────────────────────────────────────
+export function loadRelations() {
+    return loadJsonl(RELATIONS_FILE);
+}
+export function getEntityRelations(entityId) {
+    return loadRelations().filter(r => r.from_id === entityId || r.to_id === entityId);
+}
+/**
+ * Add or update a relation. If same from+to+type exists, bumps count.
+ */
+export function upsertRelation(fromId, toId, type, confidence = 0.8) {
+    const relations = loadRelations();
+    const existing = relations.find(r => r.from_id === fromId && r.to_id === toId && r.type === type);
+    if (existing) {
+        existing.count++;
+        existing.last_seen = Date.now();
+        existing.confidence = Math.min(existing.confidence + 0.05, 1.0);
+        saveJsonl(RELATIONS_FILE, relations);
+    }
+    else {
+        appendJsonl(RELATIONS_FILE, {
+            id: uid(),
+            from_id: fromId,
+            to_id: toId,
+            type,
+            confidence,
+            count: 1,
+            last_seen: Date.now(),
+        });
+    }
+}
+// ─── Search ───────────────────────────────────────────────────────────────
+/**
+ * Search entities by name/alias substring match.
+ */
+export function searchEntities(query, limit = 10) {
+    const lower = query.toLowerCase().trim();
+    if (!lower)
+        return [];
+    return loadEntities()
+        .filter(e => e.name.toLowerCase().includes(lower) ||
+        e.aliases.some(a => a.toLowerCase().includes(lower)))
+        .sort((a, b) => b.reference_count - a.reference_count)
+        .slice(0, limit);
+}
+// ─── Context building (for system prompt injection) ───────────────────────
+const MAX_BRAIN_CHARS = 1500;
+/**
+ * Build context string for entities mentioned in the conversation.
+ * Returns empty string if no relevant entities found.
+ */
+export function buildEntityContext(mentionedNames) {
+    if (mentionedNames.length === 0)
+        return '';
+    const entities = loadEntities();
+    const matched = [];
+    for (const name of mentionedNames) {
+        const entity = findEntity(entities, name);
+        if (entity)
+            matched.push(entity);
+    }
+    if (matched.length === 0)
+        return '';
+    const lines = ['# Known Entities'];
+    let chars = lines[0].length;
+    for (const entity of matched) {
+        const observations = getEntityObservations(entity.id)
+            .sort((a, b) => b.confidence - a.confidence)
+            .slice(0, 5);
+        const relations = getEntityRelations(entity.id);
+        const header = `\n## ${entity.name} (${entity.type})`;
+        if (chars + header.length > MAX_BRAIN_CHARS)
+            break;
+        lines.push(header);
+        chars += header.length;
+        for (const obs of observations) {
+            const line = `- ${obs.content}`;
+            if (chars + line.length + 1 > MAX_BRAIN_CHARS)
+                break;
+            lines.push(line);
+            chars += line.length + 1;
+        }
+        for (const rel of relations.slice(0, 3)) {
+            const otherEntity = entities.find(e => e.id === (rel.from_id === entity.id ? rel.to_id : rel.from_id));
+            if (!otherEntity)
+                continue;
+            const line = `- ${rel.type} → ${otherEntity.name}`;
+            if (chars + line.length + 1 > MAX_BRAIN_CHARS)
+                break;
+            lines.push(line);
+            chars += line.length + 1;
+        }
+    }
+    return lines.length > 1 ? lines.join('\n') : '';
+}
+// ─── Stats ────────────────────────────────────────────────────────────────
+export function getBrainStats() {
+    return {
+        entities: loadEntities().length,
+        observations: loadObservations().length,
+        relations: loadRelations().length,
+    };
+}

package/dist/brain/types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Franklin Brain — entity-based knowledge graph.
+ * Inspired by GBrain (Garry Tan). Lightweight JSONL, no database.
+ */
+export type EntityType = 'person' | 'project' | 'company' | 'product' | 'concept';
+export interface Entity {
+    id: string;
+    type: EntityType;
+    name: string;
+    aliases: string[];
+    created_at: number;
+    updated_at: number;
+    reference_count: number;
+}
+export interface Observation {
+    id: string;
+    entity_id: string;
+    content: string;
+    source: string;
+    confidence: number;
+    tags: string[];
+    created_at: number;
+}
+export interface Relation {
+    id: string;
+    from_id: string;
+    to_id: string;
+    type: string;
+    confidence: number;
+    count: number;
+    last_seen: number;
+}
+export interface BrainExtraction {
+    entities: Array<{
+        name: string;
+        type: EntityType;
+        aliases?: string[];
+        observations: string[];
+    }>;
+    relations: Array<{
+        from: string;
+        to: string;
+        type: string;
+    }>;
+}

package/dist/brain/types.js

@@ -0,0 +1,5 @@
+/**
+ * Franklin Brain — entity-based knowledge graph.
+ * Inspired by GBrain (Garry Tan). Lightweight JSONL, no database.
+ */
+export {};

package/dist/commands/daemon.js

@@ -50,7 +50,8 @@ export async function daemonCommand(action, options) {
             fs.mkdirSync(BLOCKRUN_DIR, { recursive: true });
             const child = spawn(runcodeBin, ['proxy', '--port', String(port)], {
                 detached: true,
-                stdio: ['ignore', fs.openSync(LOG_FILE, 'a'), fs.openSync(LOG_FILE, 'a')],
+                // stdout → /dev/null (banner + startup messages), stderr → log file (debug/errors only)
+                stdio: ['ignore', 'ignore', fs.openSync(LOG_FILE, 'a')],
             });
             child.unref();
             fs.writeFileSync(PID_FILE, String(child.pid));

package/dist/commands/start.js

@@ -7,6 +7,7 @@ import { printBanner } from '../banner.js';
 import { assembleInstructions } from '../agent/context.js';
 import { interactiveSession } from '../agent/loop.js';
 import { allCapabilities, createSubAgentCapability } from '../tools/index.js';
+import { validateToolDescriptions } from '../tools/validate.js';
 import { launchInkUI } from '../ui/app.js';
 import { pickModel, resolveModel } from '../ui/model-picker.js';
 import { loadMcpConfig } from '../mcp/config.js';
@@ -112,7 +113,7 @@ export async function startCommand(options) {
         onBalanceFetched?.(balStr);
     })();
     // Assemble system instructions
-    const systemInstructions = assembleInstructions(workDir);
+    const systemInstructions = assembleInstructions(workDir, model);
     // Connect MCP servers (non-blocking — add tools if servers are available)
     const mcpConfig = loadMcpConfig(workDir);
     let mcpTools = [];
@@ -133,6 +134,13 @@ export async function startCommand(options) {
     // Build capabilities (built-in + MCP + sub-agent)
     const subAgent = createSubAgentCapability(apiUrl, chain, allCapabilities);
     const capabilities = [...allCapabilities, ...mcpTools, subAgent];
+    // Validate tool descriptions (self-evolution: detect SearchX-style description bugs)
+    if (options.debug) {
+        const issues = validateToolDescriptions(capabilities);
+        for (const issue of issues) {
+            console.error(`[validate] ${issue.severity}: ${issue.toolName} — ${issue.issue}`);
+        }
+    }
     // Agent config
     const agentConfig = {
         model,
@@ -214,11 +222,16 @@ async function runWithInkUI(agentConfig, model, workDir, version, walletInfo, on
     if (sessionHistory && sessionHistory.length >= 4) {
         try {
             const { extractLearnings } = await import('../learnings/extractor.js');
+            const { extractBrainEntities } = await import('../brain/extract.js');
             const { ModelClient } = await import('../agent/llm.js');
             const client = new ModelClient({ apiUrl: agentConfig.apiUrl, chain: agentConfig.chain });
+            const sid = `session-${new Date().toISOString()}`;
             await Promise.race([
-                extractLearnings(sessionHistory, `session-${new Date().toISOString()}`, client),
-                new Promise(resolve => setTimeout(resolve, 10_000)),
+                Promise.all([
+                    extractLearnings(sessionHistory, sid, client),
+                    extractBrainEntities(sessionHistory, sid, client),
+                ]),
+                new Promise(resolve => setTimeout(resolve, 15_000)),
             ]);
         }
         catch { /* extraction is best-effort */ }

package/dist/config.js

@@ -11,7 +11,7 @@ try {
 catch { /* use default */ }
 export const VERSION = _version;
 // Shared User-Agent string for all outbound HTTP requests
-export const USER_AGENT = `runcode/${_version} (node/${process.versions.node}; ${process.platform}; ${process.arch})`;
+export const USER_AGENT = `franklin/${_version} (node/${process.versions.node}; ${process.platform}; ${process.arch})`;
 export const BLOCKRUN_DIR = path.join(os.homedir(), '.blockrun');
 export const CHAIN_FILE = path.join(BLOCKRUN_DIR, 'payment-chain');
 export const API_URLS = {

package/dist/index.js

@@ -173,10 +173,25 @@ program
 });
 // Default action: if no subcommand given, run 'start'
 const args = process.argv.slice(2);
-const knownCommands = program.commands.map(c => c.name());
 const firstArg = args[0];
+const HELP_FLAGS = new Set(['-h', '--help']);
+const VERSION_FLAGS = new Set(['-V', '--version']);
+const START_ONLY_FLAGS = new Set(['--trust', '--debug', '-m', '--model']);
+function hasAnyFlag(argv, flags) {
+    return argv.some(arg => flags.has(arg));
+}
+function hasStartOnlyFlag(argv) {
+    return argv.some(arg => START_ONLY_FLAGS.has(arg));
+}
 // Handle chain shortcuts: `runcode solana` or `runcode base`
 if (firstArg === 'solana' || firstArg === 'base') {
+    if (hasAnyFlag(args, HELP_FLAGS)) {
+        program.parse(['node', 'franklin', 'start', '--help']);
+    }
+    if (hasAnyFlag(args, VERSION_FLAGS)) {
+        console.log(version);
+        process.exit(0);
+    }
     const { saveChain } = await import('./config.js');
     saveChain(firstArg);
     const startOpts = { version };
@@ -192,7 +207,17 @@ if (firstArg === 'solana' || firstArg === 'base') {
     await startCommand(startOpts);
     process.exit(0);
 }
-else if (!firstArg || (firstArg.startsWith('-') && !['-h', '--help', '-V', '--version'].includes(firstArg))) {
+else if (!firstArg || firstArg.startsWith('-')) {
+    if (hasAnyFlag(args, HELP_FLAGS) && hasStartOnlyFlag(args)) {
+        program.parse(['node', 'franklin', 'start', '--help']);
+    }
+    if (hasAnyFlag(args, VERSION_FLAGS) && hasStartOnlyFlag(args)) {
+        console.log(version);
+        process.exit(0);
+    }
+    if (hasAnyFlag(args, HELP_FLAGS) || hasAnyFlag(args, VERSION_FLAGS)) {
+        program.parse();
+    }
     // No subcommand or only flags — treat as 'start' with flags
     const startOpts = { version };
     for (let i = 0; i < args.length; i++) {

package/dist/learnings/extractor.d.ts

@@ -14,3 +14,16 @@ export declare function bootstrapFromClaudeConfig(client: ModelClient): Promise<
  * Runs asynchronously — caller should fire-and-forget.
  */
 export declare function extractLearnings(history: Dialogue[], sessionId: string, client: ModelClient): Promise<void>;
+/**
+ * Check if mid-session extraction should run, and if so, run it in background.
+ * Called from the agent loop after tool execution completes.
+ *
+ * Triggers when:
+ * 1. Token count exceeds init threshold (first extraction) OR update threshold (subsequent)
+ * 2. AND enough tool calls have happened since last extraction
+ * 3. AND we haven't hit the per-session cap
+ *
+ * Inspired by Claude Code's SessionMemory which runs a background subagent
+ * to extract conversation notes periodically.
+ */
+export declare function maybeMidSessionExtract(history: Dialogue[], estimatedTokens: number, totalToolCalls: number, sessionId: string, client: ModelClient): void;

package/dist/learnings/extractor.js

@@ -6,17 +6,19 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { loadLearnings, mergeLearning, saveLearnings } from './store.js';
-// Cheapest models that reliably output structured JSON
+// Free models for learning extraction — JSON extraction is simple enough.
+// Ordered by reliability: try the best free model first, fall back to others.
 const EXTRACTION_MODELS = [
-    'google/gemini-2.5-flash-lite',
-    'google/gemini-2.5-flash',
-    'nvidia/nemotron-super-49b',
+    'nvidia/nemotron-ultra-253b', // Best free model for structured output
+    'nvidia/qwen3-coder-480b', // Strong at JSON tasks
+    'nvidia/devstral-2-123b', // Fallback
 ];
 const VALID_CATEGORIES = new Set([
     'language', 'model_preference', 'tool_pattern', 'coding_style',
-    'communication', 'domain', 'correction', 'workflow', 'other',
+    'communication', 'domain', 'correction', 'negative', 'project_context',
+    'workflow', 'other',
 ]);
-const EXTRACTION_PROMPT = `You are analyzing a conversation between a user and an AI coding agent. Extract user preferences and behavioral patterns that would help personalize future interactions.
+const EXTRACTION_PROMPT = `You are analyzing a conversation between a user and an AI coding agent. Extract user preferences, behavioral patterns, and project knowledge that would help personalize future interactions.
 
 Analyze for:
 1. Language — what language does the user write in? (English, Chinese, mixed?)
@@ -25,16 +27,21 @@ Analyze for:
 4. Communication — are they terse or verbose? Do they want explanations or just code?
 5. Domain — what tech stack, frameworks, or project type?
 6. Corrections — did they repeatedly correct the same agent behavior?
-7. Workflow — do they prefer short tasks or long planning sessions?
+7. **Negative signals** — did the user say "don't do X", "stop doing Y", "never Z"? These are HIGH PRIORITY (confidence 0.9+). Use category "negative".
+8. **Project context** — architecture decisions, key file locations, deployment patterns, team conventions. Use category "project_context".
+9. Workflow — do they prefer short tasks or long planning sessions?
 
 Rules:
 - ONLY extract signals clearly supported by evidence in the conversation.
 - Do NOT speculate. If evidence is weak, set confidence below 0.5.
+- **Negative signals get HIGH confidence** (0.9+) — when a user says "don't" or "stop" or corrects the agent, that's a strong signal.
+- **Project context gets MEDIUM confidence** (0.7) — architecture/tech decisions are usually deliberate.
 - If the conversation is too short or generic, return an empty array.
 - Each learning should be one clear, actionable sentence.
+- For negative learnings, start with "NEVER" or "Do NOT" to make the instruction clear.
 
 Respond with ONLY a JSON object (no markdown fences, no commentary):
-{"learnings":[{"learning":"...","category":"language|model_preference|tool_pattern|coding_style|communication|domain|correction|workflow|other","confidence":0.5}]}`;
+{"learnings":[{"learning":"...","category":"language|model_preference|tool_pattern|coding_style|communication|domain|correction|negative|project_context|workflow|other","confidence":0.5}]}`;
 /**
  * Condense session history into a compact text for extraction.
  * Only includes user messages and assistant text — skips tool calls/results.
@@ -198,6 +205,9 @@ export async function extractLearnings(history, sessionId, client) {
     const condensed = condenseHistory(history);
     if (condensed.length < 100)
         return; // Too little content
+    await runExtraction(condensed, sessionId, client);
+}
+async function runExtraction(condensed, sessionId, client) {
     // Try each model until one succeeds
     let result = null;
     for (const model of EXTRACTION_MODELS) {
@@ -232,3 +242,54 @@ export async function extractLearnings(history, sessionId, client) {
     }
     saveLearnings(existing);
 }
+const midSessionState = {
+    lastExtractionTokens: 0,
+    lastExtractionToolCalls: 0,
+    extractionCount: 0,
+};
+/** Token threshold before first mid-session extraction */
+const MID_SESSION_INIT_THRESHOLD = 30_000;
+/** Token growth since last extraction to trigger another */
+const MID_SESSION_UPDATE_THRESHOLD = 25_000;
+/** Minimum tool calls since last extraction */
+const MID_SESSION_TOOL_CALLS_THRESHOLD = 5;
+/** Max mid-session extractions per session (don't spam) */
+const MID_SESSION_MAX_EXTRACTIONS = 3;
+/**
+ * Check if mid-session extraction should run, and if so, run it in background.
+ * Called from the agent loop after tool execution completes.
+ *
+ * Triggers when:
+ * 1. Token count exceeds init threshold (first extraction) OR update threshold (subsequent)
+ * 2. AND enough tool calls have happened since last extraction
+ * 3. AND we haven't hit the per-session cap
+ *
+ * Inspired by Claude Code's SessionMemory which runs a background subagent
+ * to extract conversation notes periodically.
+ */
+export function maybeMidSessionExtract(history, estimatedTokens, totalToolCalls, sessionId, client) {
+    // Cap reached — stop extracting
+    if (midSessionState.extractionCount >= MID_SESSION_MAX_EXTRACTIONS)
+        return;
+    // Check token threshold
+    const tokenGrowth = estimatedTokens - midSessionState.lastExtractionTokens;
+    const threshold = midSessionState.extractionCount === 0
+        ? MID_SESSION_INIT_THRESHOLD
+        : MID_SESSION_UPDATE_THRESHOLD;
+    if (tokenGrowth < threshold)
+        return;
+    // Check tool calls threshold
+    const toolCallGrowth = totalToolCalls - midSessionState.lastExtractionToolCalls;
+    if (toolCallGrowth < MID_SESSION_TOOL_CALLS_THRESHOLD)
+        return;
+    // Trigger extraction — fire and forget (never blocks the conversation)
+    midSessionState.lastExtractionTokens = estimatedTokens;
+    midSessionState.lastExtractionToolCalls = totalToolCalls;
+    midSessionState.extractionCount++;
+    const condensed = condenseHistory(history);
+    if (condensed.length < 100)
+        return;
+    // Run in background — errors are silently swallowed
+    runExtraction(condensed, `${sessionId}:mid-${midSessionState.extractionCount}`, client)
+        .catch(() => { });
+}

package/dist/learnings/index.d.ts

@@ -1,3 +1,3 @@
 export type { Learning, LearningCategory, ExtractionResult } from './types.js';
 export { loadLearnings, saveLearnings, mergeLearning, decayLearnings, formatForPrompt } from './store.js';
-export { extractLearnings, bootstrapFromClaudeConfig } from './extractor.js';
+export { extractLearnings, bootstrapFromClaudeConfig, maybeMidSessionExtract } from './extractor.js';

package/dist/learnings/index.js

@@ -1,2 +1,2 @@
 export { loadLearnings, saveLearnings, mergeLearning, decayLearnings, formatForPrompt } from './store.js';
-export { extractLearnings, bootstrapFromClaudeConfig } from './extractor.js';
+export { extractLearnings, bootstrapFromClaudeConfig, maybeMidSessionExtract } from './extractor.js';

package/dist/learnings/store.js

@@ -111,20 +111,49 @@ const MAX_PROMPT_CHARS = 2000; // ~500 tokens
 export function formatForPrompt(learnings) {
     if (learnings.length === 0)
         return '';
-    const sorted = [...learnings].sort((a, b) => score(b) - score(a));
-    const lines = [];
+    // Separate negative learnings (highest priority) from others
+    const negative = learnings.filter(l => l.category === 'negative');
+    const projectCtx = learnings.filter(l => l.category === 'project_context');
+    const preferences = learnings.filter(l => l.category !== 'negative' && l.category !== 'project_context');
+    const sections = [];
     let chars = 0;
-    const header = '# Personal Context\nPreferences learned from previous sessions:\n';
-    chars += header.length;
-    for (const l of sorted) {
-        const conf = l.confidence >= 0.8 ? '●' : l.confidence >= 0.5 ? '◐' : '○';
-        const line = `- ${conf} ${l.learning}`;
-        if (chars + line.length + 1 > MAX_PROMPT_CHARS)
-            break;
-        lines.push(line);
-        chars += line.length + 1;
+    // Negative learnings first (most important — prevents repeating mistakes)
+    if (negative.length > 0) {
+        const negSorted = [...negative].sort((a, b) => score(b) - score(a));
+        const negLines = negSorted
+            .filter(l => { if (chars + l.learning.length + 5 > MAX_PROMPT_CHARS)
+            return false; chars += l.learning.length + 5; return true; })
+            .map(l => `- ⛔ ${l.learning}`);
+        if (negLines.length > 0) {
+            sections.push('## Rules (from past corrections)\n' + negLines.join('\n'));
+        }
+    }
+    // Project context
+    if (projectCtx.length > 0) {
+        const ctxSorted = [...projectCtx].sort((a, b) => score(b) - score(a));
+        const ctxLines = ctxSorted
+            .filter(l => { if (chars + l.learning.length + 5 > MAX_PROMPT_CHARS)
+            return false; chars += l.learning.length + 5; return true; })
+            .map(l => `- ${l.learning}`);
+        if (ctxLines.length > 0) {
+            sections.push('## Project Context\n' + ctxLines.join('\n'));
+        }
+    }
+    // General preferences
+    if (preferences.length > 0) {
+        const prefSorted = [...preferences].sort((a, b) => score(b) - score(a));
+        const prefLines = prefSorted
+            .filter(l => { if (chars + l.learning.length + 5 > MAX_PROMPT_CHARS)
+            return false; chars += l.learning.length + 5; return true; })
+            .map(l => {
+            const conf = l.confidence >= 0.8 ? '●' : l.confidence >= 0.5 ? '◐' : '○';
+            return `- ${conf} ${l.learning}`;
+        });
+        if (prefLines.length > 0) {
+            sections.push('## Preferences\n' + prefLines.join('\n'));
+        }
     }
-    if (lines.length === 0)
+    if (sections.length === 0)
         return '';
-    return header + lines.join('\n');
+    return '# Personal Context\nLearned from previous sessions:\n\n' + sections.join('\n\n');
 }