dsh-tacit 0.2.1 → 0.2.3

package/lib/service.js

@@ -8,8 +8,9 @@
  * an `ok` flag and a stable error `code` the client localizes. Expected
  * failures never throw; unexpected ones are mapped by the route layer.
  *
- * Only user-triggered model calls exist here (analyzeTurn / improveDraft):
- * there is no background work, no polling, no telemetry.
+ * Model calls are either user-triggered (analyzeTurn / improveDraft /
+ * bootstrap) or automatic analyses of messy and corrected turns, the latter
+ * capped by `autoDailyBudget`. There is no polling and no telemetry.
  */
 
 import {
@@ -43,6 +44,9 @@ import {
   normalizeReport,
   parseJsonObject,
   ANALYSIS_SYSTEM_PROMPT,
+  GOOD_SYSTEM_PROMPT,
+  GOOD_TOOL,
+  normalizeGoodReport,
   ANALYSIS_REPAIR_SYSTEM_PROMPT,
   IMPROVE_SYSTEM_PROMPT,
   IMPROVE_REPAIR_SYSTEM_PROMPT,
@@ -70,7 +74,10 @@ import {
   DIRECTIVE_TIMEOUT_MS,
   MAX_DIRECTIVES,
   buildDirectiveUserText,
+  buildSteeringSection,
   renderSteeringSection,
+  workspaceLabel,
+  MAX_WORKSPACE_DIRECTIVES,
   ENRICH_SYSTEM_PROMPT,
   ENRICH_TOOL,
   ENRICH_MAX_TOKENS,
@@ -110,6 +117,8 @@ export function mergeConfig(base, patch) {
   merged.enrichPrompts = merged.enrichPrompts === true
   merged.directiveTrialTurns = Math.max(1, Math.min(500, Math.round(Number(merged.directiveTrialTurns) || 10)))
   merged.directiveWorseBy = Math.max(0, Math.min(1, Number.isFinite(Number(merged.directiveWorseBy)) ? Number(merged.directiveWorseBy) : 0.15))
+  merged.bootstrapConcurrency = Math.max(1, Math.min(4, Math.round(Number(merged.bootstrapConcurrency) || 1)))
+  merged.learnFromGood = merged.learnFromGood !== false
   return merged
 }
 
@@ -133,15 +142,44 @@ function turnsOf(service, sessionId) {
   }
 }
 
-/** A human label for a session: the workspace directory's basename, else ''. */
-function sessionLabelOf(service, sessionId) {
-  const session = typeof service.sessions?.get === 'function' ? service.sessions.get(sessionId) : undefined
+/** The absolute 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
-  if (typeof cwd !== 'string' || cwd.length === 0) return ''
-  const parts = cwd.split(/[\\/]+/).filter((part) => part.length > 0)
-  return parts.length > 0 ? parts[parts.length - 1] : ''
+  return typeof cwd === 'string' && cwd.length > 0 ? cwd : undefined
+}
+
+/** A human label for a session: the workspace directory's basename, else ''. */
+function sessionLabelOf(service, sessionId) {
+  const session = typeof service.sessions?.get === 'function' ? service.sessions.get(sessionId) : undefined
+  return workspaceLabel(cwdOf(session))
+}
+
+/** 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))
+}
+
+/** 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
 }
 
 /** Short, secret-free context digest of a session's last two finished turns. */
@@ -219,6 +257,9 @@ export function createCoachService(ctx, store, effectiveConfig) {
   const rewriteRecords = new Map()
   /** sessionId → FIFO [{rewriteId, baseline}] (one per applied rewrite). */
   const pendingVerifications = new Map()
+  /** sessionId → ids of the directives in that session's frozen steering (bounded; insertion order = age). */
+  const steeringIdsBySession = new Map()
+  const MAX_STEERING_SESSIONS = 500
   let distillInFlight = false
   let rewriteSeq = 0
 
@@ -234,7 +275,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
     return 'd' + Date.now().toString(36) + '-' + directiveSeq.toString(36)
   }
   let directivesInFlight = false
-  /** Steering text frozen per live session (keeps the model's prefix cache stable within a session). */
+  /** Steering `{ text, ids }` frozen per live session object (keeps the model's prefix cache stable within a session). */
   const steeringFrozen = new WeakMap()
 
   const nextRewriteId = () => {
@@ -271,7 +312,7 @@ export function createCoachService(ctx, store, 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 = profile.directives.slice(0, MAX_DIRECTIVES)
+    profile.directives = capDirectives(profile.directives)
     profile.updatedAt = Date.now()
     const validated = profileSchema.parse(profile)
     store.saveProfile(validated)
@@ -285,7 +326,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
    * Returns the profile with fresh rules on success, the input profile on a
    * soft no-op/failure.
    */
-  const maybeDistill = async (profile, provider) => {
+  const maybeDistill = async (profile, provider, sessionId) => {
     if (profile.pendingDistill < 3 || distillInFlight) return profile
     distillInFlight = true
     try {
@@ -299,6 +340,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
         maxTokens: DISTILL_MAX_TOKENS,
         timeoutMs: DISTILL_TIMEOUT_MS,
         tool: DISTILL_TOOL,
+        sessionId,
       })
       const rules = normalizeDistillRules(text)
       if (rules.length === 0) return profile
@@ -352,10 +394,12 @@ export function createCoachService(ctx, store, effectiveConfig) {
 
   /**
    * Directive trials ride the same free feed: every NEW finished turn counts
-   * toward each candidate; after `directiveTrialTurns` the candidate is
-   * activated, or retired when the messy rate rose past the baseline by more
-   * than `directiveWorseBy`. Steering text is frozen per session, so a verdict
-   * reaches new sessions only — by design.
+   * 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.
    */
   const recordTrialTurns = (sessionId, turns) => {
     const fresh = (Array.isArray(turns) ? turns : []).filter((turn) => turn !== null && typeof turn === 'object'
@@ -363,8 +407,10 @@ export function createCoachService(ctx, store, effectiveConfig) {
       && !seenFinished.has(sessionId + ':' + turn.turn))
     if (fresh.length === 0) return
     for (const turn of fresh) seenFinished.add(sessionId + ':' + turn.turn)
+    const steered = steeringIdsBySession.get(sessionId)
+    if (steered === undefined || steered.length === 0) return
     const profile = safeProfile()
-    const candidates = profile.directives.filter((entry) => entry.status === 'candidate' && entry.trial !== undefined)
+    const candidates = profile.directives.filter((entry) => entry.status === 'candidate' && entry.trial !== undefined && steered.includes(entry.id))
     if (candidates.length === 0) return
     const config = effectiveConfig()
     const messyCount = fresh.filter((turn) => isMessyTurn(turn, { minSteps: Number.POSITIVE_INFINITY })).length
@@ -430,6 +476,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
       const svc = serviceOf(ctx)
       const { session, turns } = turnsOf(svc, sessionId)
       if (session === undefined) return { ok: false, report: null, profile, code: 'no-session', detail: '' }
+      const cwd = cwdOf(session)
       // The change feed already carries the digest; a manual click re-reads the snapshot.
       const record = digest !== null && typeof digest === 'object' ? digest : turns.find((candidate) => candidate?.turn === turn)
       if (record === undefined) return { ok: false, report: null, profile, code: 'not-retained', detail: '' }
@@ -446,6 +493,40 @@ export function createCoachService(ctx, store, effectiveConfig) {
         const provider = typeof record.provider === 'string' && record.provider.length > 0
           ? record.provider
           : COACH_PROVIDER
+        if (trigger === 'good') {
+          // One attempt, no repair retry: a recovery lesson is a bonus, not a diagnosis.
+          const goodText = await callCoachModel(ctx, {
+            provider,
+            model: config.model,
+            system: GOOD_SYSTEM_PROMPT,
+            userText,
+            maxTokens: ANALYZE_MAX_TOKENS,
+            timeoutMs: ANALYZE_TIMEOUT_MS,
+            tool: GOOD_TOOL,
+            sessionId,
+          })
+          const goodParsed = goodText.trim() === '' ? null : parseJsonObject(goodText)
+          if (goodParsed === null) return { ok: false, report: null, profile, code: 'empty-response', detail: '' }
+          const goodReport = {
+            ...normalizeGoodReport(goodParsed, { turn, time: Date.now(), model: config.model, prompt: record.prompt }),
+            ...(typeof record.prompt === 'string' && record.prompt.length > 0 ? { promptExcerpt: clipSafe(record.prompt, 200) } : {}),
+            trigger,
+            ...(cwd !== undefined ? { cwd } : {}),
+          }
+          if (goodReport.lesson === '' && goodReport.strengths.length === 0) {
+            return { ok: false, report: null, profile, code: 'nothing-learned', detail: '' }
+          }
+          const isNew = store.report(sessionId, turn) === null
+          store.saveReport(sessionId, turn, goodReport)
+          const grown = aggregateProfile(store.profile(), goodReport, config.maxPatterns, { countNew: isNew })
+          if (isNew) grown.analysesSinceDirectives = (grown.analysesSinceDirectives ?? 0) + 1
+          store.saveProfile(grown)
+          if (isNew && !bootstrapState.running) {
+            const task = maybeDistillDirectives(sessionId, provider).catch(() => null).finally(() => autoRunning.delete(task))
+            autoRunning.add(task)
+          }
+          return { ok: true, report: goodReport, profile: grown, code: '', detail: '' }
+        }
         let text = await callCoachModel(ctx, {
           provider,
           model: config.model,
@@ -492,6 +573,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
             : {}),
           trigger,
           ...(followUp.length > 0 ? { followUp: clipSafe(followUp, 300) } : {}),
+          ...(cwd !== undefined ? { cwd } : {}),
         }
         const countNew = store.report(sessionId, turn) === null
         store.saveReport(sessionId, turn, report)
@@ -512,23 +594,31 @@ export function createCoachService(ctx, store, effectiveConfig) {
     return exclusive
   }
 
-  const steeringStatus = () => {
+  const steeringStatus = (cwd) => {
     const config = effectiveConfig()
-    return { enabled: config.steerAgent, text: config.steerAgent ? renderSteeringSection(safeProfile()) : '' }
+    return { enabled: config.steerAgent, text: config.steerAgent ? renderSteeringSection(safeProfile(), { cwd }) : '' }
   }
 
+  /** What a session in `cwd` assembling its system prompt right now would get. */
+  const steeringNow = (cwd) => (effectiveConfig().steerAgent ? buildSteeringSection(safeProfile(), { cwd }) : { text: '', ids: [] })
+
   /** The system-prompt section provider (sync; frozen per session). */
   const steeringText = (assemble) => {
     const session = assemble !== null && typeof assemble === 'object' && assemble.agent !== null && typeof assemble.agent === 'object'
       ? assemble.agent.session
       : undefined
-    if (session === null || session === undefined || typeof session !== 'object') return steeringStatus().text
+    if (session === null || session === undefined || typeof session !== 'object') return steeringNow().text
     let frozen = steeringFrozen.get(session)
     if (frozen === undefined) {
-      frozen = steeringStatus().text
+      frozen = steeringNow(cwdOf(session))
       steeringFrozen.set(session, frozen)
+      if (typeof session.id === 'string' && session.id.length > 0) {
+        steeringIdsBySession.delete(session.id)
+        steeringIdsBySession.set(session.id, frozen.ids)
+        while (steeringIdsBySession.size > MAX_STEERING_SESSIONS) steeringIdsBySession.delete(steeringIdsBySession.keys().next().value)
+      }
     }
-    return frozen
+    return frozen.text
   }
 
   /**
@@ -536,35 +626,58 @@ export function createCoachService(ctx, store, effectiveConfig) {
    * entries are untouched, and a re-emitted directive keeps the enabled flag
    * the user gave its identical text. Capped at MAX_DIRECTIVES overall.
    */
-  const mergeDirectives = (profile, texts) => {
-    const previous = new Map(profile.directives.filter((entry) => entry.source !== 'user').map((entry) => [entry.text.trim().toLowerCase(), entry]))
+  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 }) : []
+    const turns = scoped.length >= 20 ? scoped : allFinishedTurns()
+    return computeTrend(turns, { window: 20 }).recent.messyRate
+  }
+
+  /**
+   * 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.
+   */
+  const mergeDirectives = (profile, items) => {
     const users = profile.directives.filter((entry) => entry.source === 'user')
-    const userKeys = new Set(users.map((entry) => entry.text.trim().toLowerCase()))
+    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()
-    let baselineRate = null
-    for (const text of texts) {
-      const key = text.trim().toLowerCase()
+    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 })
+        distilled.push({ ...kept, text: item.text })
         continue
       }
       // A new distilled directive goes on trial against the current messy-turn rate.
-      if (baselineRate === null) baselineRate = computeTrend(allFinishedTurns(), { window: 20 }).recent.messyRate
+      if (!baselines.has(scope)) baselines.set(scope, baselineRateFor(scope === '' ? undefined : scope))
       distilled.push({
         id: nextDirectiveId(),
-        text,
+        text: item.text,
         enabled: true,
         source: 'distilled',
         createdAt: Date.now(),
         status: 'candidate',
-        trial: { turns: 0, messy: 0, baselineRate, startedAt: Date.now() },
+        trial: { turns: 0, messy: 0, baselineRate: baselines.get(scope), startedAt: Date.now() },
+        ...(scope === '' ? {} : { workspace: scope }),
       })
     }
-    profile.directives = [...users, ...distilled].slice(0, MAX_DIRECTIVES)
+    profile.directives = capDirectives([...users, ...distilled, ...untouched])
     return profile
   }
 
@@ -577,6 +690,13 @@ export function createCoachService(ctx, store, effectiveConfig) {
     directivesInFlight = true
     try {
       const recent = store.listAllReports(20).map((entry) => store.report(entry.sessionId, entry.turn)).filter((report) => report !== null)
+      // 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 text = await callCoachModel(ctx, {
         provider,
         model: config.model,
@@ -587,16 +707,20 @@ export function createCoachService(ctx, store, effectiveConfig) {
         tool: DIRECTIVE_TOOL,
         sessionId,
       })
-      const { kept: texts, rejected } = classifyDirectives(text)
+      const { kept, rejected } = classifyDirectives(text)
       for (const dropped of rejected) console.warn('[tacit] dropped directive (it asks the user instead of compensating):', dropped)
-      if (texts.length === 0) {
+      if (kept.length === 0) {
         console.warn('[tacit] directive distillation returned nothing usable; will retry after the next analysis:', clipSafe(text, 300))
         return
       }
-      profile = mergeDirectives(safeProfile(), texts)
+      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)
       profile.analysesSinceDirectives = 0
       capAndSaveProfile(profile)
-      console.info('[tacit] distilled ' + texts.length + ' directive(s) into the steering section')
+      const scoped = items.filter((item) => item.workspace !== undefined).length
+      console.info('[tacit] distilled ' + items.length + ' directive(s) into the steering section' + (scoped > 0 ? ' (' + scoped + ' workspace-specific)' : ''))
     } catch (error) {
       // Soft: the counter stays and the next analysis retries.
       console.warn('[tacit] directive distillation failed (will retry):', error instanceof Error ? error.message : String(error))
@@ -646,13 +770,14 @@ export function createCoachService(ctx, store, effectiveConfig) {
     }
   }
 
-  /** Every live session's finished turns, for the measured trend. */
-  const allFinishedTurns = () => {
+  /** Every live session's finished turns (optionally only sessions in one workspace), for the measured trend. */
+  const allFinishedTurns = ({ cwd } = {}) => {
     const svc = serviceOf(ctx)
     const sessions = typeof svc.sessions?.list === 'function' ? svc.sessions.list() : []
     const out = []
     for (const session of Array.isArray(sessions) ? sessions : []) {
       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)
     }
@@ -665,7 +790,8 @@ export function createCoachService(ctx, store, effectiveConfig) {
   /**
    * "Learn from my last N turns now": explicit user action, so it ignores the
    * daily auto budget. Skips continuations, tiny prompts and turns that already
-   * have a report; then forces one directive distillation.
+   * have a report; runs up to `bootstrapConcurrency` analyses at once (same
+   * number of calls either way); then forces one directive distillation.
    */
   const runBootstrap = async ({ sessionId, limit }) => {
     if (bootstrapState.running) return { ok: false, analyzed: 0, skipped: 0, directives: 0, code: 'busy', detail: '' }
@@ -700,19 +826,29 @@ export function createCoachService(ctx, store, effectiveConfig) {
     bootstrapState.total = eligible.length
     bootstrapState.startedAt = Date.now()
     let analyzed = 0
-    let lastProvider = COACH_PROVIDER
     try {
-      for (const item of eligible) {
-        const previous = previousFinishedOf(item.turns, item.turn.turn)
-        const result = await runAnalysis(item.sessionId, item.turn.turn, { trigger: 'bootstrap', digest: item.turn, previousDigest: previous })
-        if (result !== null && typeof result === 'object' && result.ok === true) analyzed += 1
-        else console.warn('[tacit] bootstrap: ' + item.sessionId + ':' + item.turn.turn + ' skipped: ' + (result?.code ?? 'unknown'))
-        lastProvider = providerForSession(item.sessionId)
-        bootstrapState.done += 1
+      // A small worker pool: each worker pulls the next eligible turn until the
+      // list is drained. Analyses for different turns never share an in-flight
+      // key, and the profile read-modify-write inside runAnalysis has no await,
+      // so concurrent analyses cannot lose each other's counts.
+      let next = 0
+      const worker = async () => {
+        while (next < eligible.length) {
+          const item = eligible[next]
+          next += 1
+          const previous = previousFinishedOf(item.turns, item.turn.turn)
+          const result = await runAnalysis(item.sessionId, item.turn.turn, { trigger: 'bootstrap', digest: item.turn, previousDigest: previous })
+          if (result !== null && typeof result === 'object' && result.ok === true) analyzed += 1
+          else console.warn('[tacit] bootstrap: ' + item.sessionId + ':' + item.turn.turn + ' skipped: ' + (result?.code ?? 'unknown'))
+          bootstrapState.done += 1
+        }
       }
+      const concurrency = Math.min(effectiveConfig().bootstrapConcurrency, Math.max(1, eligible.length))
+      await Promise.all(Array.from({ length: concurrency }, () => worker()))
       if (analyzed > 0) {
         await service.flushAuto() // let any scheduled distillation settle before forcing one
-        await maybeDistillDirectives(eligible[0].sessionId, lastProvider, { force: true })
+        // The forced distillation is attributed to the newest eligible turn's session.
+        await maybeDistillDirectives(eligible[0].sessionId, providerForSession(eligible[0].sessionId), { force: true })
       }
     } finally {
       bootstrapState.running = false
@@ -753,12 +889,14 @@ export function createCoachService(ctx, store, effectiveConfig) {
   }
 
   /**
-   * Zero-click learning. Two triggers, both free (no model call to decide):
+   * Zero-click learning. Three triggers, all free (no model call to decide):
    *  - the newest FINISHED turn is messy (retries / tool errors / compactions /
    *    rejection / long step run);
    *  - the newest (possibly unfinished) turn's prompt reads as a correction of
    *    the previous answer → the PREVIOUS turn is analyzed with that
-   *    follow-up attached as evidence.
+   *    follow-up attached as evidence;
+   *  - (learnFromGood) the newest finished turn is clean right after a messy
+   *    one → a small "what did the user include this time" call.
    * Turns finished before the plugin started are ignored (cold restore).
    */
   const maybeAutoAnalyze = (sessionId, turns) => {
@@ -774,6 +912,14 @@ export function createCoachService(ctx, store, effectiveConfig) {
       // the conversation is its context. Heavy work after it is not a prompt fault.
       if (fresh(newest) && isMessyTurn(newest, { minSteps: config.autoMinSteps }) && !looksLikeContinuation(newest.prompt)) {
         scheduleAuto(sessionId, newest.turn, { trigger: 'auto', digest: newest, previousDigest: previous })
+        return
+      }
+      // A recovery: clean now, messy just before, with a real prompt in between.
+      const recovery = config.learnFromGood && fresh(newest) && !looksLikeContinuation(newest.prompt)
+        && typeof newest.prompt === 'string' && newest.prompt.trim().length >= ENRICH_MIN_DRAFT_CHARS
+        && previous !== null && previous.finished === true && isMessyTurn(previous, { minSteps: config.autoMinSteps })
+      if (recovery) {
+        scheduleAuto(sessionId, newest.turn, { trigger: 'good', digest: newest, previousDigest: previous })
       }
       return
     }
@@ -790,13 +936,18 @@ export function createCoachService(ctx, store, effectiveConfig) {
       await Promise.all([...autoRunning])
     },
 
-    async getState() {
+    /** Optional `{ sessionId }`: the steering preview is then rendered for that conversation's workspace. */
+    async getState(args) {
+      const svc = serviceOf(ctx)
+      const sessionId = args !== null && typeof args === 'object' && typeof args.sessionId === 'string' && args.sessionId.length > 0 ? args.sessionId : null
+      const session = sessionId !== null && typeof svc.sessions?.get === 'function' ? svc.sessions.get(sessionId) : undefined
       return {
         ok: true,
         config: effectiveConfig(),
         profile: safeProfile(),
         auto: autoStatus(),
-        steering: steeringStatus(),
+        steering: steeringStatus(cwdOf(session)),
+        workspaces: listWorkspaces(svc),
         bootstrap: { ...bootstrapState },
         message: '',
       }
@@ -843,7 +994,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
       // Distillation also fires on user-triggered improve calls (soft, in-flight
       // deduped, never awaited: an improve call is never blocked by it).
       if (profile.pendingDistill >= 3) {
-        maybeDistill(profile, providerForSession(sessionId)).catch(() => {})
+        maybeDistill(profile, providerForSession(sessionId), sessionId).catch(() => {})
       }
       // Only trusted (or still-inexperienced) patterns reach the prompt;
       // style rules + the last 3 verbatim down-reasons ride along for free
@@ -948,7 +1099,7 @@ export function createCoachService(ctx, store, effectiveConfig) {
       // user action. Awaited so the returned profile already carries the
       // fresh style rules; a failure is soft-silent and retries later.
       if (profile.pendingDistill >= 3) {
-        profile = await maybeDistill(profile, providerForSession(record.sessionId))
+        profile = await maybeDistill(profile, providerForSession(record.sessionId), record.sessionId)
       }
       return { ok: true, profile, code: '', detail: '' }
     },
@@ -997,7 +1148,8 @@ export function createCoachService(ctx, store, effectiveConfig) {
       } 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' }
-        profile.directives.push({ id: nextDirectiveId(), text, enabled: true, source: 'user', createdAt: Date.now() })
+        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 }) })
       } else {
         profile.directives = profile.directives.filter((entry) => entry.id !== input.id)
       }

package/lib/store.js

@@ -149,6 +149,7 @@ export class CoachStore {
           promptExcerpt: typeof report.promptExcerpt === 'string' ? report.promptExcerpt : '',
           improvedPrompt: typeof report.improvedPrompt === 'string' ? report.improvedPrompt : '',
           trigger: typeof report.trigger === 'string' ? report.trigger : 'manual',
+          cwd: typeof report.cwd === 'string' ? report.cwd : '',
         })
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-tacit",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Tacit learns what you leave unsaid in your prompts — from messy turns and your own corrections, with zero clicks — and tells the agent how to compensate, on every turn, via a system-prompt section you can read and edit.",
   "author": "hackernotfound",
   "license": "MIT",
@@ -29,7 +29,7 @@
   },
   "files": [
     "lib",
-    "client",
+    "client/client.js",
     "cordis.patch.yml",
     "README.md",
     "LICENSE",
@@ -37,7 +37,9 @@
   ],
   "scripts": {
     "test": "node --test",
-    "check": "pnpm test && pnpm check:docs && pnpm check:package",
+    "build:client": "node scripts/build-client.mjs",
+    "check": "pnpm test && pnpm check:client && pnpm check:docs && pnpm check:package",
+    "check:client": "node scripts/build-client.mjs --check",
     "check:docs": "node scripts/check-doc-links.mjs",
     "check:package": "node scripts/check-package.mjs",
     "smoke": "node scripts/smoke.mjs"
@@ -86,13 +88,17 @@
     }
   },
   "dependencies": {
-    "@deepseek-ai/dsh-home-paths": "^0.1.1-rc.2",
-    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
     "zod": "^4.4.3"
   },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-home-paths": ">=0.1.1-rc.2 <0.2.0",
+    "@deepseek-ai/dsh-llm": ">=0.1.1-rc.2 <0.2.0"
+  },
   "devDependencies": {
-    "react": "^18.3.1",
-    "react-dom": "^18.3.1"
+    "@deepseek-ai/dsh-home-paths": "^0.1.1-rc.2",
+    "@deepseek-ai/dsh-llm": "^0.1.1-rc.2",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8"
   },
   "keywords": [
     "deepseek",