dsh-tacit 0.3.0 → 0.5.0

package/lib/service.js

@@ -32,6 +32,7 @@ import {
   bootstrapArgSchema,
   usageArgSchema,
   usageRunArgSchema,
+  directiveReceiptArgSchema,
 } from './schema.js'
 import { dayKey } from './store.js'
 import { createUsageTracker, totalTokens } from './usage.js'
@@ -71,21 +72,26 @@ import {
   ANALYSIS_TOOL,
   IMPROVE_TOOL,
   DISTILL_TOOL,
+  POLICY_RE,
   clipSafe,
   isMessyTurn,
   looksLikeCorrection,
   looksLikeContinuation,
+  looksLikeJobNotification,
   classifyDirectives,
   DIRECTIVE_SYSTEM_PROMPT,
   DIRECTIVE_TOOL,
   DIRECTIVE_MAX_TOKENS,
   DIRECTIVE_TIMEOUT_MS,
-  MAX_DIRECTIVES,
   buildDirectiveUserText,
+  directiveLabels,
   buildSteeringSection,
   renderSteeringSection,
-  workspaceLabel,
-  MAX_WORKSPACE_DIRECTIVES,
+  scopeOf,
+  capDirectives,
+  mergeDirectives,
+  isDeadDirective,
+  MAX_DIRECTIVE_EVIDENCE,
   ENRICH_SYSTEM_PROMPT,
   ENRICH_TOOL,
   ENRICH_MAX_TOKENS,
@@ -96,7 +102,9 @@ import {
   buildEnrichUserText,
   normalizeEnrichNote,
   computeTrend,
+  markCorrections,
 } from './analyze.js'
+import { normalizeWorkspace, workspaceContains, workspaceLabel, workspaceLabels } from './workspace.js'
 
 /** In-memory rewrite ledger bounds (never persisted). */
 const MAX_REWRITE_RECORDS = 50
@@ -160,12 +168,13 @@ function turnsOf(service, sessionId) {
   }
 }
 
-/** The absolute workspace directory a session was created in, else undefined. */
+/** The normalised workspace directory a session was created in, else undefined. */
 function cwdOf(session) {
   const cwd = session !== null && typeof session === 'object' && session.header !== null && typeof session.header === 'object'
     ? session.header.cwd
     : undefined
-  return typeof cwd === 'string' && cwd.length > 0 ? cwd : undefined
+  const workspace = normalizeWorkspace(cwd)
+  return workspace.length > 0 ? workspace : undefined
 }
 
 /** A human label for a session: the workspace directory's basename, else ''. */
@@ -177,32 +186,30 @@ function sessionLabelOf(service, sessionId) {
 /** Every distinct workspace among the live sessions, labelled for the UI. */
 function listWorkspaces(service) {
   const sessions = typeof service.sessions?.list === 'function' ? service.sessions.list() : []
-  const seen = new Map()
-  for (const session of Array.isArray(sessions) ? sessions : []) {
-    const cwd = cwdOf(session)
-    if (cwd !== undefined && !seen.has(cwd)) seen.set(cwd, { cwd, label: workspaceLabel(cwd) })
-  }
-  return [...seen.values()].sort((a, b) => a.label.localeCompare(b.label))
+  const cwds = (Array.isArray(sessions) ? sessions : []).map(cwdOf).filter((cwd) => cwd !== undefined)
+  return [...workspaceLabels(cwds)]
+    .map(([cwd, label]) => ({ cwd, label }))
+    .sort((a, b) => a.label.localeCompare(b.label))
 }
 
-/** At most MAX_DIRECTIVES global directives and MAX_WORKSPACE_DIRECTIVES per workspace, order kept. */
-function capDirectives(list) {
-  const counts = new Map()
-  const out = []
-  for (const entry of list) {
-    const scope = typeof entry.workspace === 'string' && entry.workspace.length > 0 ? entry.workspace : ''
-    const limit = scope === '' ? MAX_DIRECTIVES : MAX_WORKSPACE_DIRECTIVES
-    const n = counts.get(scope) ?? 0
-    if (n >= limit) continue
-    counts.set(scope, n + 1)
-    out.push(entry)
-  }
-  return out
+/** The `workspaceSeenAt` map narrowed to the workspaces a directive still points at. */
+function pruneSeenAt(seenAt, directives) {
+  const scopes = new Set(directives.map(scopeOf))
+  return Object.fromEntries(Object.entries(seenAt).filter(([scope]) => scopes.has(scope)))
 }
 
-/** Short, secret-free context digest of a session's last two finished turns. */
+/**
+ * Bounded context of the last two turns the user actually wrote, read from the
+ * digest. Background-job notifications and bare continuations are finished
+ * turns too, and one of them landing after the last real exchange would
+ * otherwise hide the facts the rewrite needs.
+ */
 function recentContextOf(turns) {
-  const finished = (Array.isArray(turns) ? turns : []).filter((turn) => turn?.finished === true).slice(-2)
+  const written = (turn) => {
+    const prompt = typeof turn.prompt === 'string' ? turn.prompt.trim() : ''
+    return prompt.length > 0 && !looksLikeJobNotification(prompt) && !looksLikeContinuation(prompt)
+  }
+  const finished = (Array.isArray(turns) ? turns : []).filter((turn) => turn?.finished === true && written(turn)).slice(-2)
   if (finished.length === 0) return ''
   return finished.map((turn) => {
     const prompt = typeof turn.prompt === 'string' ? turn.prompt.slice(0, 600) : ''
@@ -265,6 +272,9 @@ function coachErrorCode(error) {
   const text = raw + ' ' + message
   if (/abort|timeout/i.test(text)) return 'timeout'
   if (/auth|401|403|api[ _-]?key|key not/i.test(text)) return 'no-api-key'
+  // Ahead of the rate-limit rule: an exhausted balance says "quota" too, but
+  // it will not clear by waiting, so it must not read as "try again shortly".
+  if (/\binsufficient[ _-]?(quota|balance|credit)|\bexceeded your current quota/i.test(text)) return 'no-credit'
   // Word-bounded: a bare /rate/ matches the "rate" inside "generate", and the
   // ladder now sees the raw code and message of every provider failure. A
   // trailing \b after "quota" would not do here — `_` is a word character, so
@@ -310,9 +320,15 @@ export function createCoachService(ctx, store, effectiveConfig) {
 
   const safeProfile = () => {
     const parsed = profileSchema.safeParse(store.profile())
-    return parsed.success
-      ? parsed.data
-      : { analyzedCount: 0, patterns: [], updatedAt: 0, styleRules: [], feedbackLog: [], pendingDistill: 0, directives: [], analysesSinceDirectives: 0 }
+    if (!parsed.success) {
+      return { analyzedCount: 0, patterns: [], updatedAt: 0, styleRules: [], feedbackLog: [], pendingDistill: 0, directives: [], analysesSinceDirectives: 0, workspaceSeenAt: {} }
+    }
+    for (const entry of parsed.data.directives) {
+      const workspace = normalizeWorkspace(entry.workspace)
+      if (workspace.length > 0) entry.workspace = workspace
+      else delete entry.workspace
+    }
+    return parsed.data
   }
   let directiveSeq = 0
   const nextDirectiveId = () => {
@@ -321,7 +337,9 @@ export function createCoachService(ctx, store, effectiveConfig) {
   }
   let directivesInFlight = false
   /** Steering `{ text, ids }` frozen per live session object (keeps the model's prefix cache stable within a session). */
-  const steeringFrozen = new WeakMap()
+  let steeringFrozen = new WeakMap()
+  /** Forget every open session's frozen steering: the next assembly re-freezes from the profile as it is now. */
+  const invalidateSteering = () => { steeringFrozen = new WeakMap() }
 
   const nextRewriteId = () => {
     rewriteSeq += 1
@@ -351,13 +369,24 @@ export function createCoachService(ctx, store, effectiveConfig) {
     return profile
   }
 
+  /** The normalised workspace of every session loaded right now. */
+  const liveCwds = () => listWorkspaces(serviceOf(ctx)).map((entry) => entry.cwd)
+
   /** Bound every v2 field, validate, persist; returns the stored profile. */
   const capAndSaveProfile = (profile) => {
     const config = effectiveConfig()
     profile.patterns = profile.patterns.slice(0, config.maxPatterns)
     profile.styleRules = profile.styleRules.slice(-MAX_STYLE_RULES)
     profile.feedbackLog = profile.feedbackLog.slice(-MAX_FEEDBACK_LOG)
-    profile.directives = capDirectives(profile.directives)
+    const cwds = liveCwds()
+    const seenAt = profile.workspaceSeenAt ?? {}
+    for (const entry of profile.directives) {
+      const scope = scopeOf(entry)
+      if (scope !== '' && cwds.some((cwd) => workspaceContains(scope, cwd))) seenAt[scope] = Date.now()
+    }
+    profile.workspaceSeenAt = pruneSeenAt(seenAt, profile.directives)
+    profile.directives = capDirectives(profile.directives, { seenAt: profile.workspaceSeenAt })
+    profile.workspaceSeenAt = pruneSeenAt(profile.workspaceSeenAt, profile.directives)
     profile.updatedAt = Date.now()
     const validated = profileSchema.parse(profile)
     store.saveProfile(validated)
@@ -437,26 +466,32 @@ export function createCoachService(ctx, store, effectiveConfig) {
     handleVerification(sessionId, turns)
   }
 
-  /** Finished turns already counted toward directive trials (sessionId:turn). */
+  /** Finished turns already counted toward directive trials, and turns already counted as corrected (sessionId:turn). */
   const seenFinished = new Set()
+  const seenCorrected = new Set()
 
   const pct = (rate) => String(Math.round(rate * 100)) + '%'
 
   /**
    * Directive trials ride the same free feed: every NEW finished turn counts
    * toward each candidate that was actually in that session's frozen steering
-   * text; after `directiveTrialTurns` such turns the candidate is activated,
-   * or retired when the messy rate rose past the baseline by more than
-   * `directiveWorseBy`. A session whose steering was never assembled here
-   * (started before the candidate existed, or before a restart) counts toward
-   * nobody — its turns say nothing about the candidate.
+   * text, and so does every correction of such a turn (the session's next
+   * prompt, known the moment it starts). After `directiveTrialTurns` turns the
+   * candidate is retired when its correction rate rose past the baseline by
+   * more than `directiveWorseBy` (or its messy rate by twice that), otherwise
+   * activated. A session whose steering was never assembled here (started
+   * before the candidate existed, or before a restart) counts toward nobody —
+   * its turns say nothing about the candidate.
    */
   const recordTrialTurns = (sessionId, turns) => {
-    const fresh = (Array.isArray(turns) ? turns : []).filter((turn) => turn !== null && typeof turn === 'object'
-      && turn.finished === true && typeof turn.turn === 'number' && typeof turn.endedAt === 'number' && turn.endedAt >= pluginStartedAt
-      && !seenFinished.has(sessionId + ':' + turn.turn))
-    if (fresh.length === 0) return
-    for (const turn of fresh) seenFinished.add(sessionId + ':' + turn.turn)
+    const key = (turn) => sessionId + ':' + turn.turn
+    const counted = markCorrections(turns).filter((turn) => typeof turn.turn === 'number' && turn.finished === true
+      && typeof turn.endedAt === 'number' && turn.endedAt >= pluginStartedAt)
+    const fresh = counted.filter((turn) => !seenFinished.has(key(turn)))
+    const corrected = counted.filter((turn) => turn.corrected && !seenCorrected.has(key(turn)))
+    for (const turn of fresh) seenFinished.add(key(turn))
+    for (const turn of corrected) seenCorrected.add(key(turn))
+    if (fresh.length === 0 && corrected.length === 0) return
     const steered = steeringIdsBySession.get(sessionId)
     if (steered === undefined || steered.length === 0) return
     const profile = safeProfile()
@@ -464,21 +499,35 @@ export function createCoachService(ctx, store, effectiveConfig) {
     if (candidates.length === 0) return
     const config = effectiveConfig()
     const messyCount = fresh.filter((turn) => isMessyTurn(turn, { minSteps: Number.POSITIVE_INFINITY })).length
+    let verdicts = 0
     for (const entry of candidates) {
-      entry.trial.turns += fresh.length
-      entry.trial.messy += messyCount
-      if (entry.trial.turns < config.directiveTrialTurns) continue
-      const rate = entry.trial.messy / entry.trial.turns
-      if (rate > entry.trial.baselineRate + config.directiveWorseBy) {
+      const trial = entry.trial
+      if (trial.baselineCorrectionRate < 0) trial.baselineCorrectionRate = baselinesFor(scopeOf(entry)).baselineCorrectionRate
+      trial.turns += fresh.length
+      trial.messy += messyCount
+      trial.corrected += corrected.length
+      if (trial.turns < config.directiveTrialTurns) continue
+      const correctionRate = trial.corrected / trial.turns
+      const messyRate = trial.messy / trial.turns
+      const worse = correctionRate > trial.baselineCorrectionRate + config.directiveWorseBy
+        ? 'corrections rose ' + pct(trial.baselineCorrectionRate) + ' → ' + pct(correctionRate)
+        : messyRate > trial.baselineMessyRate + 2 * config.directiveWorseBy
+          ? 'messy turns rose ' + pct(trial.baselineMessyRate) + ' → ' + pct(messyRate)
+          : null
+      verdicts += 1
+      entry.evaluatedAt = Date.now()
+      entry.updatedAt = entry.evaluatedAt
+      if (worse !== null) {
         entry.status = 'retired'
         entry.enabled = false
-        entry.retiredReason = 'messy turns ' + pct(entry.trial.baselineRate) + ' → ' + pct(rate) + ' while active'
+        entry.retiredReason = worse + ' during its trial'
         console.info('[tacit] retired directive (' + entry.retiredReason + '): ' + entry.text)
       } else {
         entry.status = 'active'
-        console.info('[tacit] activated directive (messy turns ' + pct(entry.trial.baselineRate) + ' → ' + pct(rate) + '): ' + entry.text)
+        console.info('[tacit] activated directive (corrections ' + pct(trial.baselineCorrectionRate) + ' → ' + pct(correctionRate) + '): ' + entry.text)
       }
     }
+    if (verdicts > 0) startNextTrial(profile)
     capAndSaveProfile(profile)
   }
 
@@ -519,7 +568,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
     return earlier.length > 0 ? earlier[earlier.length - 1] : null
   }
 
-  const runAnalysis = (sessionId, turn, { trigger = 'manual', followUp = '', digest = null, previousDigest = null, runId = '' } = {}) => {
+  const runAnalysis = (sessionId, turn, { trigger = 'manual', followUp = '', digest = null, previousDigest = null, runId = '', force = false } = {}) => {
     const profile = safeProfile()
     const key = `${sessionId}:${turn}`
     /** The run this analysis is billed to: the caller's batch run, or one of its own. Stays '' on a soft refusal. */
@@ -539,6 +588,10 @@ export function createCoachService(ctx, store, effectiveConfig) {
       if (trigger === 'manual' && looksLikeContinuation(record.prompt)) {
         return { ok: false, report: null, profile, code: 'continuation', detail: '' }
       }
+      // A report already exists: a second paid look at the same turn only on request.
+      if (trigger === 'manual' && !force && store.report(sessionId, turn) !== null) {
+        return { ok: false, report: null, profile, code: 'already-analyzed', detail: '' }
+      }
       const previous = previousDigest !== null && typeof previousDigest === 'object' ? previousDigest : previousFinishedOf(turns, turn)
       const userText = buildAnalysisUserText(record, { followUp, previous })
       if (userText === null) return { ok: false, report: null, profile, code: 'not-retained', detail: '' }
@@ -678,6 +731,9 @@ export function createCoachService(ctx, store, effectiveConfig) {
     if (session === null || session === undefined || typeof session !== 'object') return steeringNow().text
     let frozen = steeringFrozen.get(session)
     if (frozen === undefined) {
+      // A workspace seen for the first time may revive a paused trial.
+      const profile = safeProfile()
+      if (startNextTrial(profile)) capAndSaveProfile(profile)
       frozen = steeringNow(cwdOf(session))
       steeringFrozen.set(session, frozen)
       if (typeof session.id === 'string' && session.id.length > 0) {
@@ -689,64 +745,48 @@ export function createCoachService(ctx, store, effectiveConfig) {
     return frozen.text
   }
 
-  /**
-   * Replace the distilled directives with the model's new complete set; user
-   * entries are untouched, and a re-emitted directive keeps the enabled flag
-   * the user gave its identical text. Capped at MAX_DIRECTIVES overall.
-   */
-  const scopeOf = (entry) => (typeof entry.workspace === 'string' && entry.workspace.length > 0 ? entry.workspace : '')
-  const directiveKey = (scope, text) => scope + '\n' + text.trim().toLowerCase()
-
-  /** Messy-turn baseline for a new candidate: the workspace's own turns when there are enough, else everything. */
-  const baselineRateFor = (cwd) => {
-    const scoped = cwd !== undefined ? allFinishedTurns({ cwd }) : []
+  /** Baselines for a new trial: the workspace's own turns when there are enough, else everything. */
+  const baselinesFor = (scope) => {
+    const scoped = scope !== '' ? allFinishedTurns({ cwd: scope }) : []
     const turns = scoped.length >= 20 ? scoped : allFinishedTurns()
-    return computeTrend(turns, { window: 20 }).recent.messyRate
+    const { messyRate, correctionRate } = computeTrend(turns, { window: 20 }).recent
+    return { baselineMessyRate: messyRate, baselineCorrectionRate: correctionRate }
   }
 
   /**
-   * Merge the model's new complete set of directives ({ text, workspace? }):
-   * user entries are untouched; the global distilled set and the distilled set
-   * of every workspace the model mentioned are replaced; distilled entries of
-   * other workspaces are kept (their evidence was not in this batch). A
-   * re-emitted directive keeps its identity, state and enabled flag.
+   * One trial per scope at a time, and only in a workspace some session is
+   * loaded in: a candidate whose workspace is gone goes back to the queue and
+   * frees the slot, then the oldest enabled queued directive of every free
+   * seen scope starts its trial now, with baselines measured at this moment.
+   * Idempotent; returns whether any status changed.
    */
-  const mergeDirectives = (profile, items) => {
-    const users = profile.directives.filter((entry) => entry.source === 'user')
-    const userKeys = new Set(users.map((entry) => directiveKey(scopeOf(entry), entry.text)))
-    const prior = profile.directives.filter((entry) => entry.source !== 'user')
-    const previous = new Map(prior.map((entry) => [directiveKey(scopeOf(entry), entry.text), entry]))
-    const mentioned = new Set([''])
-    for (const item of items) mentioned.add(scopeOf(item))
-    const untouched = prior.filter((entry) => !mentioned.has(scopeOf(entry)))
-    const distilled = []
-    const seen = new Set()
-    const baselines = new Map()
-    for (const item of items) {
-      const scope = scopeOf(item)
-      const key = directiveKey(scope, item.text)
-      if (seen.has(key) || userKeys.has(key)) continue
-      seen.add(key)
-      const kept = previous.get(key)
-      if (kept !== undefined) {
-        distilled.push({ ...kept, text: item.text })
-        continue
-      }
-      // A new distilled directive goes on trial against the current messy-turn rate.
-      if (!baselines.has(scope)) baselines.set(scope, baselineRateFor(scope === '' ? undefined : scope))
-      distilled.push({
-        id: nextDirectiveId(),
-        text: item.text,
-        enabled: true,
-        source: 'distilled',
-        createdAt: Date.now(),
-        status: 'candidate',
-        trial: { turns: 0, messy: 0, baselineRate: baselines.get(scope), startedAt: Date.now() },
-        ...(scope === '' ? {} : { workspace: scope }),
-      })
+  const startNextTrial = (profile) => {
+    const cwds = liveCwds()
+    const seen = new Set([''])
+    for (const entry of profile.directives) {
+      const scope = scopeOf(entry)
+      if (scope !== '' && cwds.some((cwd) => workspaceContains(scope, cwd))) seen.add(scope)
     }
-    profile.directives = capDirectives([...users, ...distilled, ...untouched])
-    return profile
+    let changed = false
+    for (const entry of profile.directives) {
+      if (entry.status !== 'candidate' || seen.has(scopeOf(entry))) continue
+      entry.status = 'queued'
+      delete entry.trial
+      changed = true
+      console.info('[tacit] trial paused, workspace not loaded: ' + entry.text)
+    }
+    const review = effectiveConfig().reviewCandidates === true
+    const busy = new Set(profile.directives.filter((entry) => entry.status === 'candidate').map(scopeOf))
+    for (const entry of profile.directives) {
+      if (entry.status !== 'queued' || entry.enabled === false || busy.has(scopeOf(entry)) || !seen.has(scopeOf(entry))) continue
+      if (review && entry.source !== 'user' && !(entry.approvedAt > 0)) continue
+      busy.add(scopeOf(entry))
+      entry.status = 'candidate'
+      entry.trial = { turns: 0, messy: 0, corrected: 0, ...baselinesFor(scopeOf(entry)), startedAt: Date.now() }
+      changed = true
+      console.info('[tacit] directive on trial: ' + entry.text)
+    }
+    return changed
   }
 
   /** ONE small call every `directiveEvery` new analyses (or forced). Soft-fails; never throws. */
@@ -761,19 +801,19 @@ export function createCoachService(ctx, store, effectiveConfig) {
       ? usage.beginRun({ type: 'directive-distillation', trigger: 'auto', sessionId, model: config.model, provider })
       : runId
     try {
-      const recent = store.listAllReports(20).map((entry) => store.report(entry.sessionId, entry.turn)).filter((report) => report !== null)
+      const recent = store.listAllReports(20)
+        .map((entry) => ({ ...store.report(entry.sessionId, entry.turn), sessionId: entry.sessionId, turn: entry.turn }))
+        .filter((report) => report.ok !== undefined || typeof report.problems === 'object')
+      // Newest first, before the prompt builder reverses the list for the model.
+      const evidence = recent.slice(0, MAX_DIRECTIVE_EVIDENCE).map((report) => ({ sessionId: report.sessionId, turn: report.turn, trigger: typeof report.trigger === 'string' ? report.trigger : 'manual' }))
       // The model sees workspace names only; map them back to the directories they stand for.
-      const workspaces = new Map()
-      for (const report of recent) {
-        if (typeof report.cwd !== 'string' || report.cwd.length === 0) continue
-        const label = workspaceLabel(report.cwd)
-        if (label.length > 0 && !workspaces.has(label)) workspaces.set(label, report.cwd)
-      }
+      const labels = directiveLabels(profile, recent)
+      const workspaces = new Map([...labels].map(([cwd, label]) => [label, cwd]))
       const text = await callCoachModel(ctx, metered(usageRunId, { op: 'directive-distillation', sessionId }, {
         provider,
         model: config.model,
         system: DIRECTIVE_SYSTEM_PROMPT,
-        userText: buildDirectiveUserText(profile, recent.reverse()),
+        userText: buildDirectiveUserText(profile, recent.reverse(), { labels }),
         maxTokens: DIRECTIVE_MAX_TOKENS,
         timeoutMs: DIRECTIVE_TIMEOUT_MS,
         tool: DIRECTIVE_TOOL,
@@ -785,10 +825,32 @@ export function createCoachService(ctx, store, effectiveConfig) {
         console.warn('[tacit] directive distillation returned nothing usable; will retry after the next analysis:', clipSafe(text, 300))
         return
       }
-      const items = kept.map((item) => (item.workspace !== undefined && workspaces.has(item.workspace)
-        ? { text: item.text, workspace: workspaces.get(item.workspace) }
-        : { text: item.text }))
-      profile = mergeDirectives(safeProfile(), items)
+      const items = []
+      for (const item of kept) {
+        if (item.workspace !== undefined && !workspaces.has(item.workspace)) {
+          console.info('[tacit] dropped directive (its workspace "' + item.workspace + '" is not one the evidence came from):', item.text)
+          continue
+        }
+        items.push({
+          text: item.text,
+          ...(item.id === undefined ? {} : { id: item.id }),
+          ...(item.workspace === undefined ? {} : { workspace: workspaces.get(item.workspace) }),
+        })
+      }
+      if (items.length === 0) return
+      const before = new Map(safeProfile().directives.map((entry) => [entry.id, entry.text]))
+      profile = mergeDirectives(safeProfile(), items, { nextId: nextDirectiveId })
+      const now = Date.now()
+      for (const entry of profile.directives) {
+        if (entry.source === 'user' || isDeadDirective(entry)) continue
+        const previous = before.get(entry.id)
+        if (previous === entry.text) continue
+        if (previous !== undefined) entry.version = (entry.version ?? 1) + 1
+        entry.updatedAt = now
+        entry.evidence = evidence
+        entry.distillationRunId = usageRunId
+      }
+      startNextTrial(profile)
       profile.analysesSinceDirectives = 0
       capAndSaveProfile(profile)
       const scoped = items.filter((item) => item.workspace !== undefined).length
@@ -858,7 +920,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
       if (session === null || typeof session !== 'object' || typeof session.id !== 'string') continue
       if (cwd !== undefined && cwdOf(session) !== cwd) continue
       const { turns } = turnsOf(svc, session.id)
-      for (const turn of turns) if (turn?.finished === true) out.push(turn)
+      for (const turn of markCorrections(turns)) if (turn.finished === true) out.push(turn)
     }
     return out
   }
@@ -868,6 +930,19 @@ export function createCoachService(ctx, store, effectiveConfig) {
    *  deliberately not named `tokens`, which everywhere else in the ledger is the five-bucket object. */
   const bootstrapState = { running: false, done: 0, total: 0, startedAt: 0, runId: '', billedCalls: 0, unpricedCalls: 0, usdKnown: 0, tokensTotal: 0 }
 
+  /** Back to "no bootstrap has run": every field, so a no-op never shows the previous batch's figures. */
+  const resetBootstrapState = () => {
+    bootstrapState.running = false
+    bootstrapState.done = 0
+    bootstrapState.total = 0
+    bootstrapState.startedAt = 0
+    bootstrapState.runId = ''
+    bootstrapState.billedCalls = 0
+    bootstrapState.unpricedCalls = 0
+    bootstrapState.usdKnown = 0
+    bootstrapState.tokensTotal = 0
+  }
+
   /** Mirror the bootstrap run's live counters into the state the panel polls. */
   const refreshBootstrapUsage = () => {
     const summary = bootstrapState.runId === '' ? null : usage.runSummary(bootstrapState.runId)
@@ -967,6 +1042,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
     // Nothing to analyze is a no-op, not a run: an empty run would be written
     // to the ledger as `failed` (no attempts) and read as a broken bootstrap.
     if (eligible.length === 0) {
+      resetBootstrapState()
       return { ok: true, analyzed: 0, skipped, directives: safeProfile().directives.length, code: '', detail: '', run: null }
     }
     const config = effectiveConfig()
@@ -980,15 +1056,11 @@ export function createCoachService(ctx, store, effectiveConfig) {
       model: config.model,
       provider: scopedToSession ? providerForSession(sessionId) : COACH_PROVIDER,
     })
+    resetBootstrapState()
     bootstrapState.running = true
-    bootstrapState.done = 0
     bootstrapState.total = eligible.length
     bootstrapState.startedAt = Date.now()
     bootstrapState.runId = runId
-    bootstrapState.billedCalls = 0
-    bootstrapState.unpricedCalls = 0
-    bootstrapState.usdKnown = 0
-    bootstrapState.tokensTotal = 0
     let analyzed = 0
     try {
       // A small worker pool: each worker pulls the next eligible turn until the
@@ -1019,6 +1091,9 @@ export function createCoachService(ctx, store, effectiveConfig) {
       bootstrapState.running = false
       closeRun(runId, { requested: limit, eligible: eligible.length, analyzed, skipped, directives: safeProfile().directives.length })
       refreshBootstrapUsage()
+      // Mirror the final counters first, then drop the id: the tile keeps the
+      // finished run's figures, but nothing may still call it the live run.
+      bootstrapState.runId = ''
     }
     return { ok: true, analyzed, skipped, directives: safeProfile().directives.length, code: '', detail: '', run: usage.runSummary(runId) }
   }
@@ -1031,7 +1106,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
    * an auto trigger or another batch — reports `busy` and costs nothing. A
    * bootstrap running elsewhere does NOT block the batch.
    */
-  const analyzeBatch = async ({ sessionId, turns }) => {
+  const analyzeBatch = async ({ sessionId, turns, force = false }) => {
     const { session } = turnsOf(serviceOf(ctx), sessionId)
     if (session === undefined) return { ok: false, results: [], profile: safeProfile(), run: null, code: 'no-session', detail: '' }
     const wanted = [...new Set(turns)].sort((a, b) => a - b)
@@ -1055,7 +1130,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
           const at = next
           next += 1
           const turn = wanted[at]
-          const result = await runAnalysis(sessionId, turn, { trigger: 'manual', runId })
+          const result = await runAnalysis(sessionId, turn, { trigger: 'manual', runId, force })
           const ok = result !== null && typeof result === 'object' && result.ok === true
           if (ok) analyzed += 1
           results[at] = { turn, ok, code: result?.code ?? 'call-failed', report: ok ? result.report : null }
@@ -1068,8 +1143,8 @@ export function createCoachService(ctx, store, effectiveConfig) {
       // made and nothing failed, so this is a real request that succeeded —
       // not the zero-attempt `failed` run the default derivation would write.
       const entries = results.filter((entry) => entry !== null && entry !== undefined)
-      const allBusy = analyzed === 0 && entries.length === wanted.length && entries.every((entry) => entry.code === 'busy')
-      closeRun(runId, { requested: wanted.length, analyzed, skipped: wanted.length - analyzed }, allBusy ? 'success' : undefined)
+      const allSkipped = analyzed === 0 && entries.length === wanted.length && entries.every((entry) => entry.code === 'busy' || entry.code === 'already-analyzed')
+      closeRun(runId, { requested: wanted.length, analyzed, skipped: wanted.length - analyzed }, allSkipped ? 'success' : undefined)
     }
     return { ok: true, results, profile: safeProfile(), run: usage.runSummary(runId), code: '', detail: '' }
   }
@@ -1201,7 +1276,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
       if (!parsed.success) {
         return { ok: false, report: null, profile: safeProfile(), code: 'bad-request', detail: '', run: null }
       }
-      return runAnalysis(parsed.data.sessionId, parsed.data.turn, { trigger: 'manual' })
+      return runAnalysis(parsed.data.sessionId, parsed.data.turn, { trigger: 'manual', force: parsed.data.force === true })
     },
 
     /** Analyze a hand-picked set of turns of one session under a single run. */
@@ -1377,19 +1452,53 @@ export function createCoachService(ctx, store, effectiveConfig) {
         const found = profile.directives.find((entry) => entry.id === input.id)
         if (found === undefined) return { ok: false, profile, steering: steeringStatus(), code: 'bad-request', detail: 'id' }
         found.enabled = input.enabled
+        found.updatedAt = Date.now()
         // Re-enabling a retired directive is an explicit override.
         if (input.enabled && found.status === 'retired') {
           found.status = 'active'
           delete found.retiredReason
         }
+        // A candidate is always enabled: switched off, it leaves the trial slot and queues again.
+        if (!input.enabled && found.status === 'candidate') {
+          found.status = 'queued'
+          delete found.trial
+        }
+        if (!input.enabled) invalidateSteering()
+      } else if (input.action === 'start-trial') {
+        const found = profile.directives.find((entry) => entry.id === input.id)
+        if (found === undefined || found.status !== 'queued') return { ok: false, profile, steering: steeringStatus(), code: 'bad-request', detail: 'id' }
+        found.approvedAt = Date.now()
+        found.updatedAt = found.approvedAt
       } else if (input.action === 'add') {
         const text = clipSafe(input.text.trim(), 220)
         if (text.length === 0) return { ok: false, profile, steering: steeringStatus(), code: 'bad-request', detail: 'text' }
-        const workspace = typeof input.workspace === 'string' && input.workspace.trim().length > 0 ? input.workspace.trim() : undefined
-        profile.directives.push({ id: nextDirectiveId(), text, enabled: true, source: 'user', createdAt: Date.now(), ...(workspace === undefined ? {} : { workspace }) })
+        if (POLICY_RE.test(text)) return { ok: false, profile, steering: steeringStatus(), code: 'directive-policy', detail: '' }
+        const workspace = normalizeWorkspace(typeof input.workspace === 'string' ? input.workspace.trim() : '')
+        profile.directives.push({ id: nextDirectiveId(), text, enabled: true, source: 'user', createdAt: Date.now(), ...(workspace === '' ? {} : { workspace }) })
+      } else if (input.action === 'rescope') {
+        const found = profile.directives.find((entry) => entry.id === input.id)
+        if (found === undefined) return { ok: false, profile, steering: steeringStatus(), code: 'bad-request', detail: 'id' }
+        const workspace = normalizeWorkspace(input.workspace.trim())
+        if (workspace === '') delete found.workspace
+        else found.workspace = workspace
+        // A trial measured in one workspace says nothing about another.
+        if (found.status === 'candidate') {
+          found.status = 'queued'
+          delete found.trial
+        }
       } else {
-        profile.directives = profile.directives.filter((entry) => entry.id !== input.id)
+        // A tombstone, not a delete: the distiller is told about it so it never
+        // proposes the same directive (or a rewording) back.
+        const found = profile.directives.find((entry) => entry.id === input.id)
+        if (found !== undefined) {
+          found.status = 'removed'
+          found.enabled = false
+          found.updatedAt = Date.now()
+          delete found.trial
+          invalidateSteering()
+        }
       }
+      startNextTrial(profile)
       const saved = capAndSaveProfile(profile)
       return { ok: true, profile: saved, steering: steeringStatus(), code: '', detail: '' }
     },
@@ -1451,15 +1560,54 @@ export function createCoachService(ctx, store, effectiveConfig) {
     async usageReport(args) {
       const parsed = usageArgSchema.safeParse(args !== null && typeof args === 'object' ? args : {})
       if (!parsed.success) return { ok: false, code: 'bad-request', detail: '' }
-      return usage.report({
-        config: effectiveConfig(),
-        pricingStatus: pricing.status(),
-        pricingRates: pricing.rates(),
-        filters: parsed.data,
-      })
+      return {
+        ...usage.report({
+          config: effectiveConfig(),
+          pricingStatus: pricing.status(),
+          pricingRates: pricing.rates(),
+          filters: parsed.data,
+        }),
+        auto: autoStatus(),
+      }
     },
 
     /** One run with its attempt rows (a live run included); expired ids are a soft `unknown-run`. */
+    /** One directive's provenance and cost: ids, counts and money, never prompt text. */
+    async directiveReceipt(args) {
+      const parsed = directiveReceiptArgSchema.safeParse(args)
+      if (!parsed.success) return { ok: false, receipt: null, code: 'bad-request', detail: '' }
+      const entry = safeProfile().directives.find((candidate) => candidate.id === parsed.data.id)
+      if (entry === undefined) return { ok: false, receipt: null, code: 'unknown-directive', detail: '' }
+      const triggers = {}
+      const conversations = new Set()
+      for (const item of entry.evidence) {
+        triggers[item.trigger] = (triggers[item.trigger] ?? 0) + 1
+        conversations.add(item.sessionId)
+      }
+      const run = entry.distillationRunId === '' ? null : usage.run(entry.distillationRunId)
+      const attempts = run !== null && Array.isArray(run.attempts) ? run.attempts.filter((attempt) => attempt.op === 'directive-distillation') : []
+      const priced = attempts.filter((attempt) => attempt.priced !== null && typeof attempt.priced === 'object' && typeof attempt.priced.usd === 'number')
+      const receipt = {
+        id: entry.id,
+        text: entry.text,
+        scope: scopeOf(entry),
+        status: entry.status,
+        source: entry.source,
+        enabled: entry.enabled !== false,
+        createdAt: entry.createdAt,
+        updatedAt: entry.updatedAt,
+        evaluatedAt: entry.evaluatedAt,
+        approvedAt: entry.approvedAt,
+        version: entry.version,
+        trial: entry.trial ?? null,
+        retiredReason: entry.retiredReason ?? '',
+        triggers,
+        evidence: { turns: entry.evidence.length, conversations: conversations.size, items: entry.evidence },
+        cost: { runId: entry.distillationRunId, calls: attempts.length, usd: priced.length === 0 ? null : priced.reduce((sum, attempt) => sum + attempt.priced.usd, 0) },
+      }
+      return { ok: true, receipt, code: '', detail: '' }
+    },
+
     async usageRun(args) {
       const parsed = usageRunArgSchema.safeParse(args)
       if (!parsed.success) return { ok: false, run: null, code: 'bad-request', detail: '' }