@synergenius/flow-weaver-pack-weaver 0.9.195 → 0.9.197

package/src/bot/dream-task.ts

@@ -0,0 +1,167 @@
+/**
+ * DreamTask — idle-time knowledge consolidation.
+ *
+ * Runs during swarm dispatch loop idle periods to extract cross-task
+ * patterns, detect recurring failures, clean stale knowledge, and
+ * convert InsightEngine findings into knowledge entries.
+ *
+ * Purely heuristic — no LLM calls. Designed to run within 500ms.
+ * Key namespaces (non-overlapping with memory-extractor's project:*):
+ * - pattern:hot-file:*  — files modified by multiple tasks (24h TTL)
+ * - warning:recurring-failure:*  — recurring failures (7d TTL)
+ * - insight:*  — converted InsightEngine insights (7d TTL)
+ * - session:stats  — rolling session statistics (overwritten each cycle)
+ */
+
+import { KnowledgeStore, type KnowledgeEntry } from './knowledge-store.js';
+import { RunStore } from './run-store.js';
+import type { Insight, ProjectModel } from './types.js';
+
+/** Minimum time between consolidation runs (ms). */
+const COOLDOWN_MS = 60_000;
+
+/** TTL for dream-sourced entries (ms). */
+const STALE_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1000;
+
+/** TTL for hot-file patterns (ms). */
+const HOT_FILE_TTL_MS = 24 * 60 * 60 * 1000;
+
+/** Minimum confidence for converting insights to knowledge. */
+const MIN_CONFIDENCE = 0.6;
+
+export interface DreamTaskOptions {
+  projectDir: string;
+}
+
+export interface DreamResult {
+  warningsStored: number;
+  staleEntriesCleaned: number;
+  insightsConverted: number;
+  durationMs: number;
+}
+
+export class DreamTask {
+  private lastConsolidatedAt = 0;
+  private readonly projectDir: string;
+
+  constructor(opts: DreamTaskOptions) {
+    this.projectDir = opts.projectDir;
+  }
+
+  shouldRun(): boolean {
+    return Date.now() - this.lastConsolidatedAt >= COOLDOWN_MS;
+  }
+
+  async consolidate(): Promise<DreamResult> {
+    const start = Date.now();
+    this.lastConsolidatedAt = start;
+
+    const store = new KnowledgeStore(this.projectDir);
+    let warningsStored = 0;
+    let staleEntriesCleaned = 0;
+    let insightsConverted = 0;
+
+    // Phase 1: Clean stale dream-sourced entries
+    staleEntriesCleaned = this.cleanStaleEntries(store);
+
+    // Phase 2: Convert InsightEngine findings to knowledge
+    try {
+      insightsConverted = await this.convertInsights(store);
+    } catch { /* non-fatal */ }
+
+    // Phase 3: Session stats
+    try {
+      this.updateSessionStats(store);
+    } catch { /* non-fatal */ }
+
+    return {
+      warningsStored,
+      staleEntriesCleaned,
+      insightsConverted,
+      durationMs: Date.now() - start,
+    };
+  }
+
+  /**
+   * Phase 1: Remove stale dream-sourced entries.
+   * Only cleans entries with source starting with 'dream-task'.
+   */
+  private cleanStaleEntries(store: KnowledgeStore): number {
+    const now = Date.now();
+    const entries = store.list();
+    let cleaned = 0;
+
+    for (const entry of entries) {
+      if (!entry.source?.startsWith('dream-task')) continue;
+
+      const age = now - entry.createdAt;
+      const isHotFile = entry.key.startsWith('pattern:hot-file:');
+      const ttl = isHotFile ? HOT_FILE_TTL_MS : STALE_THRESHOLD_MS;
+
+      if (age > ttl) {
+        store.forget(entry.key);
+        cleaned++;
+      }
+    }
+
+    return cleaned;
+  }
+
+  /**
+   * Phase 2: Convert high-confidence InsightEngine insights to knowledge.
+   * Imports ProjectModel and InsightEngine dynamically to avoid circular deps.
+   */
+  private async convertInsights(store: KnowledgeStore): Promise<number> {
+    const { ProjectModelStore } = await import('./project-model.js');
+    const { InsightEngine } = await import('./insight-engine.js');
+
+    const pms = new ProjectModelStore(this.projectDir);
+    const model = await pms.getOrBuild();
+    if (!model) return 0;
+
+    const engine = new InsightEngine();
+    const insights = engine.analyze(model);
+    const existingKeys = new Set(store.list().map(e => e.key));
+    let converted = 0;
+
+    for (const insight of insights) {
+      if (insight.confidence < MIN_CONFIDENCE) continue;
+      if (insight.severity !== 'warning' && insight.severity !== 'critical') continue;
+
+      const key = `insight:${insight.type}:${insight.id}`;
+      if (existingKeys.has(key)) continue;
+
+      store.learn(
+        key,
+        `${insight.title}: ${insight.description}. Suggestion: ${insight.suggestion}`,
+        'dream-task:insight-engine',
+      );
+      converted++;
+    }
+
+    return converted;
+  }
+
+  /**
+   * Phase 3: Update rolling session statistics.
+   */
+  private updateSessionStats(store: KnowledgeStore): void {
+    try {
+      const runStore = new RunStore();
+      const recentRuns = runStore.list({ limit: 50 });
+
+      if (recentRuns.length === 0) return;
+
+      const successCount = recentRuns.filter(r => r.success).length;
+      const avgDuration = Math.round(
+        recentRuns.reduce((sum, r) => sum + (r.durationMs ?? 0), 0) / recentRuns.length,
+      );
+
+      store.learn(
+        'session:stats',
+        `${recentRuns.length} recent runs, ${Math.round(successCount / recentRuns.length * 100)}% success, avg ${Math.round(avgDuration / 1000)}s`,
+        'dream-task',
+      );
+    } catch { /* non-fatal */ }
+  }
+}

package/src/bot/knowledge-store.ts

@@ -42,6 +42,33 @@ export class KnowledgeStore {
     return this.readAll();
   }
 
+  /**
+   * Build a compact manifest of knowledge entries for LLM relevance selection.
+   * Returns entries sorted newest-first, capped at maxEntries.
+   * Format per line: `- [N] key (Xd ago): truncated_value`
+   */
+  static buildManifest(
+    entries: KnowledgeEntry[],
+    maxEntries = 200,
+  ): { manifest: string; entries: KnowledgeEntry[] } {
+    const now = Date.now();
+    const DAY_MS = 24 * 60 * 60 * 1000;
+    const sorted = [...entries]
+      .sort((a, b) => b.createdAt - a.createdAt)
+      .slice(0, maxEntries);
+
+    const lines = sorted.map((e, i) => {
+      const ageMs = now - e.createdAt;
+      const age = ageMs < DAY_MS
+        ? `${Math.round(ageMs / (60 * 60 * 1000))}h ago`
+        : `${Math.floor(ageMs / DAY_MS)}d ago`;
+      const value = e.value.length > 80 ? e.value.slice(0, 77) + '...' : e.value;
+      return `- [${i}] ${e.key} (${age}): ${value}`;
+    });
+
+    return { manifest: lines.join('\n'), entries: sorted };
+  }
+
   private readAll(): KnowledgeEntry[] {
     if (!fs.existsSync(this.filePath)) return [];
     const content = fs.readFileSync(this.filePath, 'utf-8').trim();

package/src/bot/post-turn-hooks.ts

@@ -0,0 +1,137 @@
+/**
+ * Post-turn hook system for the agent loop.
+ *
+ * Hooks run after each iteration of the agent loop, enabling cost checks,
+ * steering, progress reporting, and knowledge extraction between LLM turns.
+ *
+ * Hooks run sequentially (not parallel) so abort hooks fire before
+ * subsequent hooks. Errors are caught per-hook — a failing hook does
+ * not block other hooks or the agent loop.
+ */
+
+import type { TurnEndContext, TurnEndResult } from '@synergenius/flow-weaver/agent';
+import { CostTracker } from './cost-tracker.js';
+
+// ---------------------------------------------------------------------------
+// Hook interface
+// ---------------------------------------------------------------------------
+
+export type HookTiming = 'every' | 'final' | 'between';
+
+export interface PostTurnHook {
+  name: string;
+  /** When to run: 'every' = every turn, 'final' = only final turn, 'between' = only between turns */
+  timing: HookTiming;
+  execute(context: TurnEndContext): Promise<PostTurnHookResult>;
+}
+
+export interface PostTurnHookResult {
+  /** If false, abort the agent loop. Default: true. */
+  continue?: boolean;
+  /** Optional message to inject into conversation (steering nudge). */
+  injectMessage?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Hook runner
+// ---------------------------------------------------------------------------
+
+export class PostTurnHookRunner {
+  private hooks: PostTurnHook[] = [];
+
+  register(hook: PostTurnHook): void {
+    this.hooks.push(hook);
+  }
+
+  /** Returns the onTurnEnd callback to pass to runAgentLoop options. */
+  createCallback(): (ctx: TurnEndContext) => Promise<TurnEndResult | void> {
+    return async (ctx: TurnEndContext): Promise<TurnEndResult | void> => {
+      let injectMessage: string | undefined;
+
+      for (const hook of this.hooks) {
+        // Check timing
+        if (hook.timing === 'final' && !ctx.isFinalTurn) continue;
+        if (hook.timing === 'between' && ctx.isFinalTurn) continue;
+
+        try {
+          const result = await hook.execute(ctx);
+          if (result.continue === false) {
+            return { continue: false, injectMessage: result.injectMessage };
+          }
+          if (result.injectMessage) {
+            injectMessage = injectMessage
+              ? injectMessage + '\n' + result.injectMessage
+              : result.injectMessage;
+          }
+        } catch (err) {
+          // Hook failure is non-fatal — log and continue
+          if (process.env.WEAVER_VERBOSE) {
+            console.error(`[post-turn-hook] ${hook.name} failed:`, err);
+          }
+        }
+      }
+
+      if (injectMessage) return { injectMessage };
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Built-in hooks
+// ---------------------------------------------------------------------------
+
+/**
+ * Cost checkpoint — aborts the loop when cumulative cost exceeds budget.
+ * Subsumes the standalone #6 per-turn budget enforcement approach.
+ */
+export class CostCheckpointHook implements PostTurnHook {
+  name = 'cost-checkpoint';
+  timing: HookTiming = 'between';
+
+  constructor(
+    private maxCost: number,
+    private model: string,
+  ) {}
+
+  async execute(ctx: TurnEndContext): Promise<PostTurnHookResult> {
+    const cost = CostTracker.estimateCost(this.model, {
+      inputTokens: ctx.usage.promptTokens,
+      outputTokens: ctx.usage.completionTokens,
+    });
+
+    if (cost >= this.maxCost) {
+      return {
+        continue: false,
+        injectMessage: `Budget exceeded: $${cost.toFixed(4)} >= $${this.maxCost.toFixed(4)}`,
+      };
+    }
+    return {};
+  }
+}
+
+/**
+ * Progress report — emits a stream event with turn progress for UI updates.
+ */
+export class ProgressReportHook implements PostTurnHook {
+  name = 'progress-report';
+  timing: HookTiming = 'every';
+
+  constructor(
+    private emitEvent: (event: { type: string; timestamp: number; data: Record<string, unknown> }) => void,
+  ) {}
+
+  async execute(ctx: TurnEndContext): Promise<PostTurnHookResult> {
+    this.emitEvent({
+      type: 'turn-progress',
+      timestamp: Date.now(),
+      data: {
+        iteration: ctx.iteration,
+        maxIterations: ctx.maxIterations,
+        toolCallCount: ctx.toolCallCount,
+        isFinalTurn: ctx.isFinalTurn,
+        usage: ctx.usage,
+      },
+    });
+    return {};
+  }
+}

package/src/bot/profile-types.ts

@@ -92,6 +92,21 @@ export interface PhaseDescriptor {
  * not hardcoded. Each workflow can have different phases (e.g. a review
  * bot might have analyze/report/suggest instead of plan/execute/review).
  */
+/** Post-run verification config — independent review of completed work. */
+export interface VerificationConfig {
+  /** Whether verification is enabled. Default: false. */
+  enabled: boolean;
+  /** Model tier for the verification agent. Default: 'standard'. */
+  tier: ModelTier;
+  /**
+   * How often to run verification (1 = every completed task, 2 = every other, etc.).
+   * Default: 1 (always verify).
+   */
+  frequency: number;
+  /** Re-open the task if verification fails. Default: true. */
+  reopenOnFail: boolean;
+}
+
 export interface ProfileBehavior {
   /** Capability names this profile can use (e.g. ['core', 'file-ops', 'shell']). */
   capabilities?: string[];
@@ -107,6 +122,8 @@ export interface ProfileBehavior {
   exitProtocol: ExitProtocol;
   /** Structured output requirements. */
   outputContract?: OutputContract;
+  /** Post-run verification by an independent agent. */
+  verification?: VerificationConfig;
 }
 
 /** Structured exit status from a bot run. */

package/src/bot/swarm-controller.ts

@@ -32,9 +32,10 @@ import { ProfileStore } from './profile-store.js';
 import type { BotProfile, BotInstance, OrchestratorInput, OrchestratorDecision, ProfileBehavior } from './profile-types.js';
 import { buildDefaultBehavior, adjustBehaviorForComplexity } from './behavior-defaults.js';
 import type { Task, RunProgress } from './task-types.js';
-import type { WorkflowResult } from './types.js';
+import type { WorkflowResult, ProviderInfo } from './types.js';
 import { scheduleMemoryExtraction } from './memory-extraction-worker.js';
 import { shouldCompact, compactRunHistory } from './context-compactor.js';
+import { DreamTask } from './dream-task.js';
 import { callAI } from './ai-client.js';
 
 // ---------------------------------------------------------------------------
@@ -87,6 +88,11 @@ const DISPATCH_LOOP_SLEEP_MS = 2000;
 // No TASK_TIMEOUT_MS — AI call timeout (10min) in the worker is the only boundary.
 const SWARM_STATE_FILE = 'swarm.json';
 
+/** Safely access runHistory — older tasks may have `runSummaries` instead. */
+function getRunHistory(ctx: { runHistory?: unknown; runSummaries?: unknown }): Array<Record<string, unknown>> {
+  return (ctx.runHistory ?? ctx.runSummaries ?? []) as Array<Record<string, unknown>>;
+}
+
 // ---------------------------------------------------------------------------
 // SwarmController
 // ---------------------------------------------------------------------------
@@ -124,6 +130,12 @@ export class SwarmController {
   /** Frozen system prompt prefix for cross-slot Anthropic cache sharing. */
   private frozenPromptPrefix: string | null = null;
 
+  /** Background knowledge consolidation during idle periods. */
+  private dreamTask: DreamTask;
+
+  /** Counter for verification frequency gating (incremented per completed task). */
+  private verificationCounter = 0;
+
   // -----------------------------------------------------------------------
   // Singleton
   // -----------------------------------------------------------------------
@@ -154,6 +166,7 @@ export class SwarmController {
     this.orchestrator = new Orchestrator({ aiRouter: new AIRouterImpl(projectDir) });
     this.instanceManager = new InstanceManager();
     this.profileStore = new ProfileStore(projectDir);
+    this.dreamTask = new DreamTask({ projectDir });
 
     // Load persisted state or create default
     this.state = this._loadState();
@@ -550,10 +563,11 @@ export class SwarmController {
         if (t.context.budgetExhausted) return false;
         // Skip tasks in rapid-loop cooldown: if last run ended recently AND was zero-work,
         // apply exponential backoff based on stagnation count
-        if (t.context.runHistory.length > 0) {
-          const lastRun = t.context.runHistory[t.context.runHistory.length - 1];
+        const taskRunHistory = getRunHistory(t.context);
+        if (taskRunHistory.length > 0) {
+          const lastRun = taskRunHistory[taskRunHistory.length - 1];
           if ('endedAt' in lastRun && lastRun.endedAt) {
-            const secsSinceLastRun = (Date.now() - new Date(lastRun.endedAt).getTime()) / 1000;
+            const secsSinceLastRun = (Date.now() - new Date(lastRun.endedAt as string).getTime()) / 1000;
             const stag = t.context.stagnationCount;
             // Exponential backoff: 10s, 20s, 40s, 80s, 160s... based on stagnation
             const cooldownSecs = stag > 0 ? Math.min(10 * Math.pow(2, stag - 1), 300) : 0;
@@ -609,6 +623,7 @@ export class SwarmController {
           return !routableTasks.includes(t);
         }).length;
         _dl(`[dispatch] 0 routable from ${pendingTasks.length} open. parent=${pendingTasks.filter(t => t.isParent).length} budget=${pendingTasks.filter(t => t.context.budgetExhausted).length} deps-blocked=${depsBlocked}`);
+        await this._maybeDream();
         await this._sleep(DISPATCH_LOOP_SLEEP_MS, signal);
         continue;
       }
@@ -650,9 +665,9 @@ export class SwarmController {
           complexity: t.complexity ?? 'moderate',
           assignedProfile: t.assignedProfile,
           context: {
-            runHistory: t.context.runHistory.map((rp) => ({
-              outcome: rp.outcome,
-              botId: rp.botId,
+            runHistory: getRunHistory(t.context).map((rp) => ({
+              outcome: rp.outcome as string,
+              botId: rp.botId as string,
             })),
           },
         })),
@@ -791,6 +806,26 @@ export class SwarmController {
     }
   }
 
+  // -----------------------------------------------------------------------
+  // Idle-time knowledge consolidation
+  // -----------------------------------------------------------------------
+
+  private async _maybeDream(): Promise<void> {
+    if (!this.dreamTask.shouldRun()) return;
+    try {
+      const result = await this.dreamTask.consolidate();
+      if (result.staleEntriesCleaned + result.insightsConverted > 0) {
+        this.eventLog.emit({
+          type: 'dream-consolidation',
+          timestamp: Date.now(),
+          data: result as unknown as Record<string, unknown>,
+        });
+      }
+    } catch (err) {
+      if (process.env.WEAVER_VERBOSE) console.warn('[swarm] dream-task failed:', err);
+    }
+  }
+
   // -----------------------------------------------------------------------
   // Task execution
   // -----------------------------------------------------------------------
@@ -815,10 +850,13 @@ export class SwarmController {
       if (shouldCompact(task, profile.preferences?.costStrategy)) {
         try {
           const { resolveModelTier } = await import('./behavior-defaults.js');
-          const compactModel = resolveModelTier('fast', 'anthropic');
+          const { resolveProviderConfig } = await import('./agent-provider.js');
+          const detected = resolveProviderConfig('auto');
+          const providerType = detected.name;
+          const compactModel = detected.model ?? resolveModelTier('fast', providerType);
           const compactPInfo = {
-            type: 'anthropic' as const,
-            apiKey: process.env.ANTHROPIC_API_KEY,
+            type: providerType as ProviderInfo['type'],
+            apiKey: process.env.ANTHROPIC_API_KEY ?? process.env.OPENAI_API_KEY,
             model: compactModel,
           };
           const summary = await compactRunHistory(task, compactPInfo, callAI);
@@ -846,7 +884,7 @@ export class SwarmController {
         mode: task.context.files.length > 0 ? 'modify' : 'create',
         targets: task.context.files.length > 0 ? task.context.files : undefined,
         options: { autoApprove: true },
-        runHistory: task.context.runHistory,
+        runHistory: getRunHistory(task.context),
         stagnationCount: task.context.stagnationCount,
       });
 
@@ -872,7 +910,12 @@ export class SwarmController {
         taskId,
         botId: workerId,
         config: { provider: 'auto' },
-        params: { taskJson, projectDir: this.projectDir, behaviorJson },
+        params: {
+          taskJson,
+          projectDir: this.projectDir,
+          behaviorJson,
+          ...(this.frozenPromptPrefix ? { frozenPromptPrefix: this.frozenPromptPrefix } : {}),
+        },
         eventLog: runEventLog,
       });
 
@@ -949,6 +992,53 @@ export class SwarmController {
       }
     }
 
+    // Independent verification — runs after acceptance passes, before release.
+    // Uses a fresh LLM session with a potentially different model tier.
+    if (releaseStatus === 'done' && task) {
+      const behavior: import('./profile-types.js').ProfileBehavior | undefined =
+        profile.preferences?.behavior;
+      const vConfig = behavior?.verification;
+      if (vConfig?.enabled) {
+        this.verificationCounter++;
+        const shouldVerify = this.verificationCounter % vConfig.frequency === 0;
+        if (shouldVerify) {
+          try {
+            const { runVerification } = await import('../node-types/verify-task.js');
+            const { resolveProviderConfig } = await import('./agent-provider.js');
+            const { resolveModelTier } = await import('./behavior-defaults.js');
+            const detected = resolveProviderConfig('auto');
+            const verifyModel = resolveModelTier(vConfig.tier, detected.name);
+            const verifyResult = await runVerification(
+              {
+                taskTitle: task.title,
+                taskDescription: task.description,
+                filesCreated: runProgress.filesCreated,
+                filesModified: runProgress.filesModified,
+                summary: runProgress.summary,
+                checks: runProgress.checks,
+              },
+              detected.name,
+              verifyModel,
+              process.env.ANTHROPIC_API_KEY ?? process.env.OPENAI_API_KEY,
+            );
+            await this.taskStore.update(taskId, { lastVerification: verifyResult } as Record<string, unknown>);
+            this.eventLog.emit({
+              type: 'verification',
+              timestamp: Date.now(),
+              data: { taskId, runId, verdict: verifyResult.verdict, summary: verifyResult.summary, cost: verifyResult.cost } as unknown as Record<string, unknown>,
+            });
+            if (verifyResult.verdict === 'fail' && vConfig.reopenOnFail) {
+              releaseStatus = 'open';
+              console.log(`\x1b[33m[swarm] verification FAILED for task ${taskId}: ${verifyResult.summary}\x1b[0m`);
+            }
+          } catch (verifyErr) {
+            if (process.env.WEAVER_VERBOSE) console.warn('[swarm] verification failed:', verifyErr);
+            // Verification failure is non-fatal — release as originally planned
+          }
+        }
+      }
+    }
+
     // Health checks — detect suspicious runs before releasing
     if (tokensUsed === 0 && runProgress.outcome === 'completed') {
       console.warn(`[swarm] HEALTH: zero-token completion task=${taskId} worker=${workerId} duration=${durationMs}ms`);
@@ -1002,7 +1092,7 @@ export class SwarmController {
             summary: runProgress.summary,
             filesModified: runProgress.filesModified,
             botId: workerId,
-            runCount: task.context.runHistory.length,
+            runCount: getRunHistory(task.context).length,
           },
         });
       }

package/src/bot/task-types.ts

@@ -60,6 +60,22 @@ export interface AcceptanceResult {
   checkedAt: string;
 }
 
+// ---------------------------------------------------------------------------
+// Verification result — independent post-run review
+// ---------------------------------------------------------------------------
+
+export type VerificationVerdict = 'pass' | 'fail' | 'inconclusive';
+
+export interface VerificationResult {
+  verdict: VerificationVerdict;
+  summary: string;
+  issues: string[];
+  filesReviewed: string[];
+  verifiedAt: string;
+  /** Cost of the verification run in USD. */
+  cost: number;
+}
+
 // ---------------------------------------------------------------------------
 // Task context
 // ---------------------------------------------------------------------------
@@ -105,6 +121,9 @@ export interface Task {
   acceptance?: AcceptanceCriteria;
   lastAcceptanceCheck?: AcceptanceResult;
 
+  // Verification
+  lastVerification?: VerificationResult;
+
   // Context
   context: TaskContext;
 

package/src/node-types/agent-execute.ts

@@ -18,6 +18,7 @@ import { resolveToolsForTask } from '../bot/tool-registry.js';
 import { auditEmit } from '../bot/audit-logger.js';
 import { withRetry, getErrorGuidance } from '../bot/error-classifier.js';
 import { CostTracker } from '../bot/cost-tracker.js';
+import { PostTurnHookRunner, CostCheckpointHook, ProgressReportHook } from '../bot/post-turn-hooks.js';
 
 // Clean up persistent sessions on process exit
 let cleanupRegistered = false;
@@ -238,13 +239,30 @@ export async function weaverAgentExecute(
     );
     const tools = WEAVER_TOOLS.filter(t => grantedToolNames.has(t.name));
 
+    // Set up post-turn hooks — cost checkpoint + progress reporting.
+    // CostCheckpointHook aborts the loop when cumulative cost exceeds budget.
+    // ProgressReportHook emits turn-progress events for UI updates.
+    const hookRunner = new PostTurnHookRunner();
+    const model = pInfo.model ?? 'claude-sonnet-4-6';
+    const budget = behavior?.budget;
+    if (budget != null && budget > 0) {
+      hookRunner.register(new CostCheckpointHook(budget, model));
+    }
+    hookRunner.register(new ProgressReportHook((event) => {
+      renderer.onStreamEvent?.({ type: 'text_delta', text: '' }); // keep renderer alive
+      if (process.env.WEAVER_VERBOSE) {
+        console.log(`[post-turn] ${event.type}: iter=${event.data.iteration} tools=${event.data.toolCallCount}`);
+      }
+    }));
+    const onTurnEnd = hookRunner.createCallback();
+
     const result = await withRetry(
       () => runAgentLoop(
         provider,
         tools,
         executor,
         [{ role: 'user', content: taskPrompt }],
-        { systemPrompt, maxIterations: 15, onToolEvent, onStreamEvent },
+        { systemPrompt, maxIterations: 15, onToolEvent, onStreamEvent, onTurnEnd },
       ),
       {
         maxRetries: 3,
@@ -256,7 +274,6 @@ export async function weaverAgentExecute(
     );
 
     const usage = result.usage;
-    const model = pInfo.model ?? 'claude-sonnet-4-6';
     const estimatedCost = CostTracker.estimateCost(model, {
       inputTokens: usage.promptTokens,
       outputTokens: usage.completionTokens,