lazyclaw 6.3.1 → 6.4.0

package/mas/index_db.mjs

@@ -13,6 +13,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import { redactSecrets } from './redact.mjs';
+import { f32ToBlob, blobToF32, blendHybrid } from './recall_blend.mjs';
 
 const SCHEMA_VERSION = 1;
 const _handles = new Map();   // configDir → { db, stmts }
@@ -64,6 +65,13 @@ function ensureSchema(db) {
       topic UNINDEXED, kind UNINDEXED
     );
     CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT);
+    -- Opt-in hybrid recall (roadmap #4): doc embeddings keyed to the FTS row's
+    -- implicit rowid + scope. Stored as a Float32 BLOB; cosine runs in JS (no
+    -- native vector extension). Empty/unused unless cfg.recall.embeddings is on.
+    CREATE TABLE IF NOT EXISTS embeddings (
+      scope TEXT, rowid_ref INTEGER, vec BLOB,
+      PRIMARY KEY (scope, rowid_ref)
+    );
   `);
   const cur = db.prepare("SELECT value FROM meta WHERE key='schema_version'").get();
   if (!cur) {
@@ -95,26 +103,31 @@ function prepareStatements(db) {
     deleteSkill: db.prepare(`DELETE FROM fts_skills WHERE skill_name = ?`),
     deleteTrajectory: db.prepare(`DELETE FROM fts_trajectories WHERE trajectory_id = ?`),
     deleteMemory: db.prepare(`DELETE FROM fts_memories WHERE topic = ? AND kind = ?`),
+    // Hybrid recall: query/insert doc embeddings by (scope, FTS rowid).
+    getEmbedding: db.prepare(`SELECT vec FROM embeddings WHERE scope = ? AND rowid_ref = ?`),
+    putEmbedding: db.prepare(`INSERT OR REPLACE INTO embeddings(scope, rowid_ref, vec) VALUES (?, ?, ?)`),
     queries: {
+      // `rowid` (FTS5 implicit) is selected so a stored embedding can be joined
+      // back to its row for the cosine blend; recall() strips it from metadata.
       sessions: db.prepare(
         `SELECT 'sessions' AS scope, bm25(fts_sessions) AS bm25,
                 snippet(fts_sessions, 0, '<mark>', '</mark>', '...', 16) AS snippet,
-                session_id, turn_idx, role, ts
+                rowid AS rowid, session_id, turn_idx, role, ts
            FROM fts_sessions WHERE content MATCH ? ORDER BY bm25 LIMIT ?`),
       skills: db.prepare(
         `SELECT 'skills' AS scope, bm25(fts_skills) AS bm25,
                 snippet(fts_skills, 0, '<mark>', '</mark>', '...', 16) AS snippet,
-                skill_name, trained_by, group_name
+                rowid AS rowid, skill_name, trained_by, group_name
            FROM fts_skills WHERE content MATCH ? ORDER BY bm25 LIMIT ?`),
       trajectories: db.prepare(
         `SELECT 'trajectories' AS scope, bm25(fts_trajectories) AS bm25,
                 snippet(fts_trajectories, 0, '<mark>', '</mark>', '...', 16) AS snippet,
-                trajectory_id, agent, outcome
+                rowid AS rowid, trajectory_id, agent, outcome
            FROM fts_trajectories WHERE content MATCH ? ORDER BY bm25 LIMIT ?`),
       memories: db.prepare(
         `SELECT 'memories' AS scope, bm25(fts_memories) AS bm25,
                 snippet(fts_memories, 0, '<mark>', '</mark>', '...', 16) AS snippet,
-                topic, kind
+                rowid AS rowid, topic, kind
            FROM fts_memories WHERE content MATCH ? ORDER BY bm25 LIMIT ?`),
     },
   };
@@ -148,7 +161,12 @@ export function closeIndex(configDir = defaultConfigDir()) {
 }
 
 function _stmts(configDir) {
-  if (!_handles.has(configDir)) openIndex(configDir);
+  // Hot path (recall + session/trajectory writes). Skip the O(index-size)
+  // PRAGMA integrity_check here — because each turn is a fresh process, paying
+  // it on the first index touch stalls the first user turn by 50-80ms+ (and
+  // growing). It is reserved for `doctor` / `index rebuild`, which open/run it
+  // explicitly; corruption then surfaces at query time (logged) instead.
+  if (!_handles.has(configDir)) openIndex(configDir, { runIntegrityCheck: false });
   return _handles.get(configDir).stmts;
 }
 
@@ -183,6 +201,22 @@ export function indexSkill(row, configDir = defaultConfigDir()) {
   }
 }
 
+// Remove a skill's FTS row so an archived/removed skill stops surfacing in
+// recall. Until now deleteSkill only ran as an upsert prelude inside
+// indexSkill; skills.removeSkill unlinks the .md but left the stale FTS row
+// recallable. Best-effort like the index writers — a delete hiccup must
+// never fail the caller's archive/remove path.
+export function deleteSkill(skillName, configDir = defaultConfigDir()) {
+  try {
+    const s = _stmts(configDir);
+    s.deleteSkill.run(String(skillName || ''));
+  } catch (e) {
+    _logIndexFailure(configDir, 'skills', e);
+    // eslint-disable-next-line no-console
+    console.warn('[index_db] deleteSkill failed:', e.message);
+  }
+}
+
 export function indexTrajectory(row, configDir = defaultConfigDir()) {
   try {
     const s = _stmts(configDir);
@@ -260,15 +294,27 @@ export function recall(query, opts = {}) {
   // Over-fetch when a where-filter is set: post-filter can drop most
   // hits, so request 2x k from FTS5 so the final trimmed slice has
   // enough to fill k. Capped at the FTS5-side 200 hard limit.
-  const fetchK = whereKeys.length ? Math.min(200, k * 2) : k;
+  // Hybrid blend over the same candidates needs a wider FTS pool to re-rank.
+  const blend = !!(opts.queryVector && opts.queryVector.length);
+  const fetchK = blend ? Math.min(200, Math.max(k * 4, 40))
+    : (whereKeys.length ? Math.min(200, k * 2) : k);
   const hits = [];
+  const rowmeta = [];  // parallel to hits: { scope, rowid } for the cosine join
   for (const sc of scope) {
     const stmt = s.queries[sc];
     if (!stmt) continue;
     try {
       const rows = stmt.all(safeQuery, fetchK);
       for (const r of rows) {
-        const { scope: sc2, bm25, snippet, ...metadata } = r;
+        // `rowid` is destructured OUT so it never leaks into the returned
+        // metadata (keeps the hit shape byte-stable for non-blend callers).
+        const { scope: sc2, bm25, snippet, rowid, ...metadata } = r;
+        // snippet() wraps the matched term in <mark>..</mark>; recall hits
+        // are fed verbatim into agent prompts, where the markup is noise.
+        // Return plain text — strip the tags FTS5 injected.
+        const plainSnippet = typeof snippet === 'string'
+          ? snippet.replace(/<\/?mark>/g, '')
+          : snippet;
         // Apply where-filter at row level — keeps the bm25 ordering
         // intact and avoids re-fetching after sort.
         if (whereKeys.length) {
@@ -278,7 +324,8 @@ export function recall(query, opts = {}) {
           }
           if (skip) continue;
         }
-        hits.push({ scope: sc2, rank: hits.length, bm25, snippet, metadata });
+        hits.push({ scope: sc2, rank: hits.length, bm25, snippet: plainSnippet, metadata });
+        rowmeta.push({ scope: sc2, rowid });
       }
     } catch (e) {
       // FTS5 MATCH syntax errors are caller mistakes; skip silently.
@@ -287,13 +334,59 @@ export function recall(query, opts = {}) {
       if (!/syntax error|no such column/i.test(e.message)) throw e;
     }
   }
-  hits.sort((a, b) => a.bm25 - b.bm25);
-  const trimmed = hits.slice(0, k);
+  // Opt-in hybrid re-rank when the caller supplies a query vector; otherwise
+  // the exact pure-FTS bm25 order (today's behavior) is preserved.
+  const getVec = (sc, rid) => { const row = s.getEmbedding.get(sc, rid); return row ? blobToF32(row.vec) : null; };
+  const ordered = blend
+    ? blendHybrid(hits, rowmeta, opts.queryVector, getVec, opts.weights)
+    : hits.sort((a, b) => a.bm25 - b.bm25);
+  const trimmed = ordered.slice(0, k);
   for (let i = 0; i < trimmed.length; i++) trimmed[i].rank = i;
   const elapsedNs = process.hrtime.bigint() - t0;
   return { query, hits: trimmed, latencyMs: Number(elapsedNs) / 1e6 };
 }
 
+// Backfill doc embeddings for FTS rows that don't have one yet. Opt-in: a no-op
+// (returns 0) when cfg.recall.embeddings is off or no embedder resolves (the
+// default / $0 path). Runs OFF the chat write hot path — call it explicitly
+// (a reindex, a CLI command, or a background pass) so a network embedding call
+// never lands on a reply. Best-effort: embed/store failures are swallowed and
+// logged so a flaky embedder can never corrupt the FTS index. Returns the
+// number of rows embedded.
+export async function backfillEmbeddings(configDir = defaultConfigDir(), cfg = {}, opts = {}) {
+  const { getEmbedder } = await import('./embedder.mjs');
+  const embedder = getEmbedder(cfg, opts);
+  if (!embedder) return 0;
+  const db = openIndex(configDir, { runIntegrityCheck: false });
+  const s = _stmts(configDir);
+  const limit = Number(opts.limit) || 500;
+  const SCOPES = {
+    sessions: 'fts_sessions', skills: 'fts_skills',
+    trajectories: 'fts_trajectories', memories: 'fts_memories',
+  };
+  let embedded = 0;
+  for (const [scope, table] of Object.entries(SCOPES)) {
+    let rows;
+    try {
+      rows = db.prepare(
+        `SELECT f.rowid AS rowid, f.content AS content FROM ${table} f
+          WHERE f.rowid NOT IN (SELECT rowid_ref FROM embeddings WHERE scope = ?)
+          LIMIT ?`).all(scope, limit);
+    } catch { continue; }
+    if (!rows.length) continue;
+    let vecs;
+    try { vecs = await embedder.embed(rows.map((r) => r.content)); }
+    catch (e) { _logIndexFailure(configDir, `embed:${scope}`, e); continue; }
+    for (let i = 0; i < rows.length; i++) {
+      const v = vecs[i];
+      if (!v || !v.length) continue;
+      try { s.putEmbedding.run(scope, rows[i].rowid, f32ToBlob(v)); embedded++; }
+      catch { /* swallow — never break the backfill on a single bad row */ }
+    }
+  }
+  return embedded;
+}
+
 export function integrityCheck(configDir = defaultConfigDir()) {
   const db = openIndex(configDir);
   const r = db.pragma('integrity_check', { simple: true });

package/mas/learning.mjs

@@ -19,10 +19,10 @@
 //   active-recall-miss   — a skill was recalled but failed to apply.
 //                          Decrement its confidence; archive when it
 //                          falls below the activation threshold.
-//   periodic-curation    — cron-driven skills_curator replay. Phase 2
-//                          full implementation; v5.0.10 emits a warning
-//                          and returns a no-op result so a cron entry
-//                          configured today does not crash.
+//   periodic-curation    — cron-driven skills_curator replay. Runs the
+//                          real curator (archives agent-authored skills
+//                          idle >90d) against ctx.configDir; the clock is
+//                          injectable (ctx.now) for deterministic tests.
 //
 // Hard contract: a single broken handler MUST NOT poison the others.
 // Each sub-routine is wrapped in its own try/catch so e.g. a missing
@@ -33,6 +33,7 @@ import * as skillSynth from './skill_synth.mjs';
 import * as userModeler from './user_modeler.mjs';
 import * as confidence from './confidence.mjs';
 import * as skills from '../skills.mjs';
+import * as skillsCurator from '../skills_curator.mjs';
 import { resolveTrainer } from '../providers/registry.mjs';
 import { hasClaudeCliSession } from '../providers/claude_cli_detect.mjs';
 
@@ -120,70 +121,78 @@ export async function _runPostTask(ctx, logger) {
     errors.push({ step: 'confidence', error: String(e?.message || e) });
   }
 
-  // 3. synthesizeSkill (best-effort — needs an agent + provider key).
-  //    All v5 frontmatter fields land here (trained_by, confidence,
-  //    trajectory_ref) so the produced SKILL.md is ready for recall +
-  //    cross-CLI dampening without a follow-up patch.
-  if (ctx.agent && ctx.task) {
-    try {
-      results.skill = await skillSynth.synthesizeSkill({
-        agent: { ...ctx.agent, provider: trainer.provider, model: trainer.model },
-        task: ctx.task,
-        apiKey: ctx.apiKey,
-        baseUrl: ctx.baseUrl,
-        fetchImpl: ctx.fetchImpl,
-        outcome: 'done',
-        trainedBy: trainer.provider,
-        trainedOnModel: trainer.model,
-        trajectoryRef: results.trajectory?.id || null,
-        confidence: results.confidence,
-      });
-      // Persist the produced SKILL.md into the shared skills/ dir so the
-      // next agent turn's recall surfaces it. installSynthesized forwards
-      // every v5 frontmatter field (see Group A — C6 fix in skill_synth).
-      if (results.skill && ctx.configDir) {
-        try {
-          results.installed = skillSynth.installSynthesized({
-            name: results.skill.name,
-            description: results.skill.description,
-            body: results.skill.body,
-            sourceTask: ctx.task.id || '',
-            createdBy: 'agent',
-            trainedBy: trainer.provider,
-            trainedOnModel: trainer.model,
-            trajectoryRef: results.trajectory?.id || null,
-            confidence: results.confidence,
-            outcome: 'done',
-          }, ctx.configDir);
-        } catch (e) {
-          errors.push({ step: 'skillInstall', error: String(e?.message || e) });
-          logger(`[learning] skill install failed: ${e?.message || e}\n`);
+  // 3 + 4. synthesizeSkill and updateUserModel are independent trainer/LLM
+  //    calls — updateUserModel does not consume results.skill — so run them
+  //    concurrently instead of awaiting one whole network round-trip before
+  //    starting the other. Each branch keeps its own try/catch so a failure in
+  //    one can never poison the other (module contract, top of file), and they
+  //    write disjoint keys of the shared results/errors objects.
+  await Promise.allSettled([
+    // 3. synthesizeSkill (best-effort — needs an agent + provider key). All v5
+    //    frontmatter fields land here (trained_by, confidence, trajectory_ref)
+    //    so the produced SKILL.md is ready for recall + cross-CLI dampening.
+    (async () => {
+      if (!(ctx.agent && ctx.task)) return;
+      try {
+        results.skill = await skillSynth.synthesizeSkill({
+          agent: { ...ctx.agent, provider: trainer.provider, model: trainer.model },
+          task: ctx.task,
+          apiKey: ctx.apiKey,
+          baseUrl: ctx.baseUrl,
+          fetchImpl: ctx.fetchImpl,
+          outcome: 'done',
+          trainedBy: trainer.provider,
+          trainedOnModel: trainer.model,
+          trajectoryRef: results.trajectory?.id || null,
+          confidence: results.confidence,
+        });
+        // Persist the produced SKILL.md into the shared skills/ dir so the
+        // next agent turn's recall surfaces it. installSynthesized forwards
+        // every v5 frontmatter field (see Group A — C6 fix in skill_synth).
+        if (results.skill && ctx.configDir) {
+          try {
+            results.installed = skillSynth.installSynthesized({
+              name: results.skill.name,
+              description: results.skill.description,
+              body: results.skill.body,
+              sourceTask: ctx.task.id || '',
+              createdBy: 'agent',
+              trainedBy: trainer.provider,
+              trainedOnModel: trainer.model,
+              trajectoryRef: results.trajectory?.id || null,
+              confidence: results.confidence,
+              outcome: 'done',
+            }, ctx.configDir);
+          } catch (e) {
+            errors.push({ step: 'skillInstall', error: String(e?.message || e) });
+            logger(`[learning] skill install failed: ${e?.message || e}\n`);
+          }
         }
+      } catch (e) {
+        errors.push({ step: 'skill', error: String(e?.message || e) });
+        logger(`[learning] skill synth failed: ${e?.message || e}\n`);
       }
-    } catch (e) {
-      errors.push({ step: 'skill', error: String(e?.message || e) });
-      logger(`[learning] skill synth failed: ${e?.message || e}\n`);
-    }
-  }
-
-  // 4. updateUserModel — needs session turns (any normalised
-  //    [{role, content}] list). Falls back to task.turns translated.
-  if (ctx.sessionTurns || ctx.task?.turns) {
-    try {
-      results.userModel = await userModeler.updateUserModel({
-        sessionTurns: ctx.sessionTurns || _toSessionTurns(ctx.task.turns),
-        provider: trainer.provider,
-        model: trainer.model,
-        apiKey: ctx.apiKey,
-        baseUrl: ctx.baseUrl,
-        fetchImpl: ctx.fetchImpl,
-        configDir: ctx.configDir,
-      });
-    } catch (e) {
-      errors.push({ step: 'userModel', error: String(e?.message || e) });
-      logger(`[learning] user model update failed: ${e?.message || e}\n`);
-    }
-  }
+    })(),
+    // 4. updateUserModel — needs session turns (any normalised [{role,content}]
+    //    list). Falls back to task.turns translated.
+    (async () => {
+      if (!(ctx.sessionTurns || ctx.task?.turns)) return;
+      try {
+        results.userModel = await userModeler.updateUserModel({
+          sessionTurns: ctx.sessionTurns || _toSessionTurns(ctx.task.turns),
+          provider: trainer.provider,
+          model: trainer.model,
+          apiKey: ctx.apiKey,
+          baseUrl: ctx.baseUrl,
+          fetchImpl: ctx.fetchImpl,
+          configDir: ctx.configDir,
+        });
+      } catch (e) {
+        errors.push({ step: 'userModel', error: String(e?.message || e) });
+        logger(`[learning] user model update failed: ${e?.message || e}\n`);
+      }
+    })(),
+  ]);
 
   return { trigger: 'post-task', results, errors };
 }
@@ -321,12 +330,27 @@ export async function _runActiveRecallMiss(ctx, logger) {
 
 // ── periodic-curation ────────────────────────────────────────────────
 //
-// Phase 2 full implementation. v5.0.10 emits a structured warning so a
-// cron entry created today returns a stable shape and operators can see
-// the hook fired without blowing up.
-export async function _runPeriodicCuration(_ctx, logger) {
-  logger('[learning] periodic-curation is a Phase 2 hook — no-op for now.\n');
-  return { trigger: 'periodic-curation', results: { stub: true }, errors: [] };
+// Run the real skills_curator sweep: archive agent-authored skills idle
+// for 90+ days so the recall index stops bloating the system prompt. The
+// clock is injectable (ctx.now) so the 90d boundary is reproducible in
+// tests; it defaults to the wall-clock for the cron caller. curate()
+// never throws for a single bad skill, but we still wrap the whole pass
+// so an unreadable store can't poison the funnel.
+//
+// ctx: { configDir, now?, curateImpl? }
+export async function _runPeriodicCuration(ctx, logger) {
+  // curateImpl is an injection seam for tests; production uses the real
+  // curator. Default the clock here, not in curate(), which demands a
+  // finite number.
+  const curate = typeof ctx.curateImpl === 'function' ? ctx.curateImpl : skillsCurator.curate;
+  const now = Number.isFinite(ctx.now) ? ctx.now : Date.now();
+  try {
+    const results = curate(ctx.configDir, now);
+    return { trigger: 'periodic-curation', results, errors: [] };
+  } catch (e) {
+    logger(`[learning] periodic-curation failed: ${e?.message || e}\n`);
+    return { trigger: 'periodic-curation', results: {}, errors: [{ step: 'curate', error: String(e?.message || e) }] };
+  }
 }
 
 // ── helpers ──────────────────────────────────────────────────────────

package/mas/mention_router.mjs

@@ -26,6 +26,9 @@ import * as agentMemory from './agent_memory.mjs';
 import * as skillSynth from './skill_synth.mjs';
 import * as skills from '../skills.mjs';
 import { composePromptStack } from './prompt_stack.mjs';
+import { finalizeTerminalStop } from './router_termination.mjs';
+import { postToThread, postTypingPlaceholder, clearTypingPlaceholder } from './router_posting.mjs';
+import { emit as emitEvent } from './events.mjs';
 
 export class MentionRouterError extends Error {
   constructor(message, code) {
@@ -110,6 +113,8 @@ export function buildTurnContext({ task, team, agent, agentRecord, teammates, co
       cfgDir: configDir,
       agent: agentRecord,
       workspace: task?.workspace || agentRecord.workspace || '',
+      // Recall prior sessions/trajectories/memories relevant to this task.
+      query: [task?.title, task?.description].filter(Boolean).join(' ').slice(0, 500),
     }) || '';
   } catch { /* best-effort — see comment above */ }
   // When composePromptStack emitted a Role layer (layer 3) we drop the
@@ -216,82 +221,10 @@ export function buildSkillsBlock(configDir) {
 // silently ignores them when the scope is missing). The message text
 // is no longer manually prefixed with the agent name because the
 // custom username already shows it in Slack's UI.
-async function postToThread({ task, agentRecord, text, logger = () => {}, sender }) {
-  if (!task.slackChannel || !task.slackThreadTs) return null;
-  let slack = sender;
-  let owned = false;
-  if (!slack) {
-    const { SlackChannel } = await import('../channels/slack.mjs');
-    slack = new SlackChannel({ requireInbound: false });
-    owned = true;
-    try {
-      await slack.start(async () => '', {});
-    } catch (err) {
-      logger(`[router] slack start failed: ${err?.message || err}\n`);
-      return null;
-    }
-  }
-  const threadId = `${task.slackChannel}:${task.slackThreadTs}`;
-  // When we have a real agent persona, push the text under that
-  // persona's username + icon. Otherwise (user message or system note)
-  // fall back to the bot's default identity with no decoration.
-  let body;
-  let sendOpts = {};
-  if (agentRecord) {
-    body = String(text);
-    if (agentRecord.displayName) sendOpts.username = agentRecord.displayName;
-    if (agentRecord.iconEmoji) sendOpts.icon_emoji = agentRecord.iconEmoji;
-  } else {
-    body = String(text);
-  }
-  try {
-    const res = await slack.send(threadId, body, sendOpts);
-    return res?.ts || null;
-  } catch (err) {
-    logger(`[router] slack send failed: ${err?.message || err}\n`);
-    return null;
-  } finally {
-    if (owned) await slack.stop().catch(() => {});
-  }
-}
-
-// "X is thinking…" placeholder posted into the thread before an agent
-// turn so a human reader knows work is happening. Returns the ts of
-// the placeholder so the caller can delete it once the real reply is
-// in. No-op when Slack isn't wired or the post fails.
-async function postTypingPlaceholder({ task, agentRecord, logger = () => {}, sender }) {
-  if (!task.slackChannel || !task.slackThreadTs) return { ts: null, sender: null };
-  let slack = sender;
-  let owned = false;
-  if (!slack) {
-    const { SlackChannel } = await import('../channels/slack.mjs');
-    slack = new SlackChannel({ requireInbound: false });
-    owned = true;
-    try {
-      await slack.start(async () => '', {});
-    } catch (err) {
-      logger(`[router] slack start failed: ${err?.message || err}\n`);
-      return { ts: null, sender: null };
-    }
-  }
-  const threadId = `${task.slackChannel}:${task.slackThreadTs}`;
-  const sendOpts = {};
-  if (agentRecord?.displayName) sendOpts.username = agentRecord.displayName;
-  if (agentRecord?.iconEmoji)   sendOpts.icon_emoji = agentRecord.iconEmoji;
-  try {
-    const res = await slack.send(threadId, `_:hourglass_flowing_sand: thinking…_`, sendOpts);
-    return { ts: res?.ts || null, sender: slack, owned, channel: task.slackChannel };
-  } catch (err) {
-    logger(`[router] slack typing post failed: ${err?.message || err}\n`);
-    if (owned) await slack.stop().catch(() => {});
-    return { ts: null, sender: null, owned: false };
-  }
-}
+//
+// The Slack thread I/O helpers (postToThread / postTypingPlaceholder /
+// clearTypingPlaceholder) live in ./router_posting.mjs.
 
-// Fire one reflection LLM call per agent that actually spoke during
-// this task. Each successful reflection is prepended to the agent's
-// memory file. Failures are logged but never thrown — a sticky
-// transcript that won't reflect shouldn't poison the user's terminal.
 // The agents that actually spoke during a task — the set both the
 // reflection and skill-synthesis post-task hooks iterate. 'user' and
 // 'system' pseudo-agents are excluded so an agent who never spoke
@@ -359,15 +292,6 @@ async function autoSynthSkills({ task, agentsById, apiKey, baseUrl, fetchImpl, c
   }
 }
 
-async function clearTypingPlaceholder(placeholder, logger) {
-  if (!placeholder?.ts || !placeholder?.channel || !placeholder?.sender) return;
-  const slack = placeholder.sender;
-  try { await slack.deleteMessage(placeholder.channel, placeholder.ts); }
-  catch (err) { logger(`[router] slack typing delete failed: ${err?.message || err}\n`); }
-  // Only stop a client we created here; a shared sender is closed once by run().
-  finally { if (placeholder.owned) await slack.stop().catch(() => {}); }
-}
-
 // Run agents in this team until the queue empties or budget runs out.
 //
 // Returns { task, iterations, stoppedBy: 'idle' | 'done' | 'budget' }.
@@ -389,6 +313,14 @@ export async function runTaskTurn({
   signal,
   approve,
   security,
+  // Fired with { provider, model, usage } after each agent turn that reported
+  // usage, so the caller prices each turn against that agent's rate card and
+  // feeds the cost cap (mixed-provider teams account correctly). No-op default.
+  onUsage,
+  // Default-on isolation — the flat sandbox spec applied to every tool the
+  // agents run this task. Threaded from the entrypoint (task tick / REPL),
+  // which builds it via defaultSandboxSpec. undefined → bare (byte-stable).
+  sandbox,
   // E3 — a long-lived caller (e.g. the daemon) can pass a pre-started
   // SlackChannel to reuse across many task turns; run() then neither
   // creates nor stops it. When omitted, run() opens + closes its own.
@@ -445,6 +377,10 @@ export async function runTaskTurn({
   let iterations = 0;
   let stoppedBy = 'idle';
 
+  // Live activity events for the dashboard (mas/events bus → GET /events SSE).
+  // emit() never throws, so these are pure side-channels that can't affect the turn.
+  emitEvent('task.start', { taskId: current.id, team: team.name, title: current.title || '' });
+
   while (queue.length > 0 && iterations < maxAgentTurns) {
     if (signal?.aborted) { stoppedBy = 'abort'; break; }
     const speaker = queue.shift();
@@ -463,6 +399,9 @@ export async function runTaskTurn({
     // thread.
     const typing = await postTypingPlaceholder({ task: current, agentRecord, logger, sender: slackSender });
 
+    emitEvent('turn.start', { taskId: current.id, agent: speaker, provider: agentRecord.provider, model: agentRecord.model });
+    emitEvent('agent.status', { agent: speaker, status: 'working' });
+
     let result;
     try {
       result = await agentTurn.runAgentTurn({
@@ -474,7 +413,7 @@ export async function runTaskTurn({
         userMessage: '',
         history: ctx.history,
         taskId: current.id,
-        configDir, cwd, apiKey, fetchImpl, baseUrl, signal, approve, security,
+        configDir, cwd, apiKey, fetchImpl, baseUrl, signal, approve, security, sandbox,
         // C9 — enable Anthropic prompt caching for the static system
         // prefix + tool definitions. Non-anthropic adapters ignore
         // the flag (it's a no-op for OpenAI/Gemini/claude-cli).
@@ -484,13 +423,24 @@ export async function runTaskTurn({
       await clearTypingPlaceholder(typing, logger);
       logger(`[router] agent "${speaker}" threw: ${err?.message || err}\n`);
       current = tasksMod.appendTurn(current.id, { agent: speaker, text: `(error: ${err?.message || err})`, ts: new Date().toISOString(), error: true }, configDir);
+      emitEvent('turn.end', { taskId: current.id, agent: speaker, stoppedBy: 'error' });
+      emitEvent('agent.status', { agent: speaker, status: 'idle' });
       continue;
     }
     await clearTypingPlaceholder(typing, logger);
 
+    // Report this turn's spend with its provider+model. Best-effort — a
+    // throwing/absent callback never affects the loop.
+    if (result.usage && typeof onUsage === 'function') {
+      try { onUsage({ provider: agentRecord.provider, model: agentRecord.model, usage: result.usage }); }
+      catch { /* never let cost accounting break the turn */ }
+    }
+
     const replyText = (result.text || '').trim();
     const ts = new Date().toISOString();
     current = tasksMod.appendTurn(current.id, { agent: speaker, text: replyText, ts, toolCalls: result.toolCalls?.length ? result.toolCalls : undefined }, configDir);
+    emitEvent('turn.end', { taskId: current.id, agent: speaker, stoppedBy: result.stoppedBy });
+    emitEvent('agent.status', { agent: speaker, status: 'idle' });
 
     // Slack mirror — only the user-visible text, with the agent name
     // prefixed so a human reader can follow who said what.
@@ -498,6 +448,7 @@ export async function runTaskTurn({
 
     if (replyText.includes(DONE_MARKER)) {
       current = tasksMod.patchTask(current.id, { status: 'done' }, configDir);
+      emitEvent('task.done', { taskId: current.id, status: 'done' });
       await postToThread({ task: current, agentRecord: null, text: `:white_check_mark: ${DONE_MARKER} — task closed by *${agentRecord.displayName || speaker}*.`, logger, sender: slackSender });
       stoppedBy = 'done';
       // Phase 18: fire one reflection LLM call per participating agent
@@ -521,7 +472,10 @@ export async function runTaskTurn({
     }
 
     const mentions = extractMentions(replyText, team.agents, speaker);
-    for (const m of mentions) queue.push(m);
+    for (const m of mentions) {
+      emitEvent('delegate', { taskId: current.id, from: speaker, to: m });
+      queue.push(m);
+    }
 
     // When a non-lead speaker doesn't hand off, return control to the
     // lead so the conversation doesn't strand mid-team. The lead can
@@ -530,11 +484,15 @@ export async function runTaskTurn({
       queue.push(team.lead);
     }
   }
-
   if (iterations >= maxAgentTurns) stoppedBy = 'budget';
-  // Close the Slack client once for the whole run — but only if WE opened
-  // it. A caller-provided sender is left running for the caller to reuse.
-  // All exit paths (done/budget/abort/idle) fall through to this return.
+  // C3 — strand-proof a non-DONE exit: terminal status + stop note (no-op for 'done'); task activates post-failure learning.
+  current = await finalizeTerminalStop({ stoppedBy, iterations, current, configDir, tasksMod, postToThread, slackSender, logger, task: current });
+  // A non-DONE exit (idle/budget/abort) still ends the task — the DONE path
+  // already emitted task.done above, so only emit here for the other exits.
+  if (stoppedBy !== 'done') {
+    emitEvent('task.done', { taskId: current.id, status: current.status, stoppedBy });
+  }
+  // Close the Slack client for the whole run, but only if WE opened it.
   if (ownSlackSender && slackSender) await slackSender.stop().catch(() => {});
   return { task: current, iterations, stoppedBy };
 }