feat(core): session bootstrap, quality pipeline non-blocking, trimmed memory injection

Quality pipeline UX:
- Replace cleanupUI() with inkRenderer.pause()/resume() around quality checks
- Composer now flickers briefly instead of disappearing for seconds

Session bootstrap:
- Add generateSessionBootstrap() + injectSessionBootstrap() methods
- Injects explicit [Session Bootstrap] system note on every session start,
  /new, /clear, and resumed sessions
- Surfaces top 3 memories, AGENTS.md summary, active skills, key project files

Memory efficiency:
- Trim getContextMemories() default from 20 entries to 5
- Saves ~500-1000 tokens per turn; older memories accessible via recall_memory

Author: igorcosta

src/core/agent.ts

@@ -1081,7 +1081,10 @@ export class AutohandAgent {
       llm: this.llm,
       workspaceRoot: runtime.workspaceRoot,
       model: model,
-      resetConversation: async () => this.resetConversationContext(),
+      resetConversation: async () => {
+        await this.resetConversationContext();
+        await this.injectSessionBootstrap();
+      },
       undoFileMutation: () => this.files.undoLast(),
       removeLastTurn: () => this.conversation.removeLastTurn(),
       // Status command context
@@ -1344,6 +1347,10 @@ export class AutohandAgent {
         this.sessionManager.createSession(this.runtime.workspaceRoot, model),
       ]);
 
+      // Inject explicit session bootstrap so the LLM is consciously aware of
+      // memories, AGENTS.md, skills, and project context from the first turn.
+      await this.injectSessionBootstrap();
+
       // Phase 3: Telemetry (no stdout output)
       if (session) {
         await this.telemetryManager.startSession(
@@ -1408,6 +1415,8 @@ export class AutohandAgent {
       this.sessionManager.createSession(this.runtime.workspaceRoot, model),
     ]);
 
+    await this.injectSessionBootstrap();
+
     // Start telemetry session
     if (session) {
       await this.telemetryManager.startSession(
@@ -1531,6 +1540,7 @@ If lint or tests fail, report the issues but do NOT commit.`;
     const session = await this.sessionManager.loadSession(sessionId);
 
     await this.resetConversationContext();
+    await this.injectSessionBootstrap();
     const messages = session.getMessages();
     for (const msg of messages) {
       if (msg.role === 'system') {
@@ -2541,14 +2551,19 @@ If lint or tests fail, report the issues but do NOT commit.`;
           this.persistentInput.stop();
           this.persistentInputActiveTurn = false;
         }
-        // Stop Ink renderer if active — it holds stdin/stdout and will
-        // swallow quality check output or cause stdin conflicts with spawn.
-        if (this.useInkRenderer) {
-          this.cleanupUI();
+        // Pause Ink renderer instead of destroying it. This releases stdin/stdout
+        // so spawned child processes (lint, test) work correctly, but preserves
+        // state so the composer reappears immediately after quality checks.
+        if (this.useInkRenderer && this.inkRenderer) {
+          this.inkRenderer.pause();
         }
         cleanupConsoleBridge();
         cleanupConsoleBridge = () => {}; // Prevent double-cleanup in finally
         await this.runQualityPipeline();
+        // Resume Ink so the composer is restored before runInstruction returns.
+        if (this.useInkRenderer && this.inkRenderer) {
+          this.inkRenderer.resume();
+        }
       }
     } catch (error) {
       success = false;
@@ -6488,6 +6503,71 @@ If lint or tests fail, report the issues but do NOT commit.`;
     this.updateContextUsage(this.conversation.history());
   }
 
+  /**
+   * Generate an explicit session bootstrap note that surfaces the most
+   * important context — memories, AGENTS.md, skills, and project structure —
+   * as a coherent "here's what you should know" block. This is injected as a
+   * system note so the LLM explicitly sees it, rather than passively hoping it
+   * notices buried system prompt content.
+   */
+  private async generateSessionBootstrap(): Promise<string> {
+    const parts: string[] = ['[Session Bootstrap]'];
+
+    // 1. Top memories (most relevant, limited to save tokens)
+    const memories = await this.memoryManager.getContextMemories(3);
+    if (memories) {
+      parts.push('', '## Memories & Preferences', memories);
+    }
+
+    // 2. AGENTS.md summary (first 20 lines — enough for conventions, not the full manifesto)
+    const agentsPath = path.join(this.runtime.workspaceRoot, 'AGENTS.md');
+    if (await fs.pathExists(agentsPath)) {
+      const content = await fs.readFile(agentsPath, 'utf-8');
+      const summary = content.split('\n').slice(0, 20).join('\n');
+      if (summary.trim()) {
+        parts.push('', '## Project Instructions (AGENTS.md)', summary);
+      }
+    }
+
+    // 3. Active skills
+    const activeSkills = this.skillsRegistry.getActiveSkills();
+    if (activeSkills.length > 0) {
+      parts.push('', '## Active Skills');
+      for (const skill of activeSkills) {
+        parts.push(`- **${skill.name}**: ${skill.description}`);
+      }
+    }
+
+    // 4. Lightweight project scan — key config files and top-level structure
+    const keyFiles = ['package.json', 'README.md', 'tsconfig.json', ' Cargo.toml', 'pyproject.toml', 'go.mod'];
+    const foundKeys: string[] = [];
+    for (const file of keyFiles) {
+      if (await fs.pathExists(path.join(this.runtime.workspaceRoot, file.trim()))) {
+        foundKeys.push(file.trim());
+      }
+    }
+    if (foundKeys.length > 0) {
+      parts.push('', `## Project Structure`, `Key files detected: ${foundKeys.join(', ')}`);
+    }
+
+    return parts.join('\n');
+  }
+
+  /**
+   * Inject the session bootstrap into the conversation. Called once per
+   * session start (new CLI invocation, /new, /clear, or resumed session).
+   */
+  private async injectSessionBootstrap(): Promise<void> {
+    try {
+      const bootstrap = await this.generateSessionBootstrap();
+      if (bootstrap && bootstrap.length > '[Session Bootstrap]'.length + 10) {
+        this.conversation.addSystemNote(bootstrap, '[Session Bootstrap]');
+      }
+    } catch {
+      // Bootstrap is best-effort; never block session start
+    }
+  }
+
   private availableProviders(): ProviderName[] {
     const providers: ProviderName[] = [];
     if (this.runtime.config.openrouter) providers.push('openrouter');

src/memory/MemoryManager.ts

@@ -212,22 +212,24 @@ export class MemoryManager {
   }
 
   /**
-   * Get memories formatted for LLM context injection
+   * Get memories formatted for LLM context injection.
+   * Limits to the most recent/relevant entries to avoid consuming excessive
+   * system prompt tokens. Older memories remain accessible via recall_memory.
    */
-  async getContextMemories(): Promise<string> {
+  async getContextMemories(limit = 5): Promise<string> {
     const { project, user } = await this.listAll();
     const parts: string[] = [];
 
     if (project.length > 0) {
       parts.push('## Project Memories');
-      for (const entry of project.slice(0, 10)) {
+      for (const entry of project.slice(0, limit)) {
         parts.push(`- ${entry.content}`);
       }
     }
 
     if (user.length > 0) {
       parts.push('## User Preferences');
-      for (const entry of user.slice(0, 10)) {
+      for (const entry of user.slice(0, limit)) {
         parts.push(`- ${entry.content}`);
       }
     }