dsh-tacit 0.2.2 → 0.2.3

package/lib/analyze.js

@@ -40,6 +40,25 @@ export function clipSafe(value, max) {
   return text.slice(0, end)
 }
 
+/**
+ * Clip a directive to `max` characters without ever cutting mid-word: prefer
+ * the last sentence end at or after `min`, else the last space, and mark a
+ * mid-sentence cut with an ellipsis. Text within the limit is returned as is.
+ */
+export function clipDirective(value, max = DIRECTIVE_MAX_CHARS, min = 60) {
+  const text = (typeof value === 'string' ? value : '').trim()
+  if (text.length <= max) return text
+  const head = clipSafe(text, max)
+  const sentenceEnd = Math.max(...['. ', '! ', '? ', '; ', '。', '！', '？', '；'].map((mark) => {
+    const at = head.lastIndexOf(mark)
+    return at >= min ? at + mark.trim().length : -1
+  }))
+  if (sentenceEnd > 0) return head.slice(0, sentenceEnd).trim()
+  const space = head.lastIndexOf(' ')
+  const cut = space >= min ? head.slice(0, space) : clipSafe(head, max - 1)
+  return cut.replace(/[\s,;:–—-]+$/u, '') + '…'
+}
+
 // ── Structured output: the model answers by CALLING one tool whose arguments
 // are the payload (the harness has no JSON mode; tool arguments are the
 // reliable structured channel). Text JSON is still accepted as a fallback.
@@ -88,11 +107,31 @@ export const DIRECTIVE_TOOL = {
   parameters: {
     type: 'object',
     properties: {
-      directives: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 4 },
+      directives: {
+        type: 'array',
+        minItems: 1,
+        maxItems: 4,
+        items: {
+          type: 'object',
+          properties: {
+            text: { type: 'string', maxLength: 220, description: 'one sentence, at most 25 words' },
+            workspace: { type: 'string', description: 'only when the habit shows up in exactly one workspace: that workspace name as written in the evidence' },
+          },
+          required: ['text'],
+        },
+      },
     },
     required: ['directives'],
   },
 }
+export const MAX_WORKSPACE_DIRECTIVES = 4
+
+/** The last path segment of a workspace directory — what a person calls the project. */
+export function workspaceLabel(cwd) {
+  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] : ''
+}
 export const DIRECTIVE_MAX_TOKENS = 1500
 export const DIRECTIVE_TIMEOUT_MS = 30000
 export const MAX_DIRECTIVES = 8
@@ -137,7 +176,7 @@ export function buildEnrichUserText({ draft, profile, recentContext }) {
     .filter((entry) => entry !== null && typeof entry === 'object' && entry.enabled !== false && typeof entry.text === 'string')
   if (directives.length > 0) {
     lines.push('=== WHAT THE COACH KNOWS ABOUT THIS USER ===')
-    for (const entry of directives.slice(0, MAX_DIRECTIVES)) lines.push('- ' + clipSafe(entry.text, DIRECTIVE_MAX_CHARS))
+    for (const entry of directives.slice(0, MAX_DIRECTIVES)) lines.push('- ' + clipDirective(entry.text))
     lines.push('')
   }
   const patterns = Array.isArray(profile?.patterns) ? profile.patterns.slice(0, 6) : []
@@ -226,6 +265,47 @@ const improveShape = z.object({
   rationale: z.string().default(''),
 })
 
+/**
+ * Learning from a recovery: the turn went cleanly right after a messy one in
+ * the same conversation. One small call names what the user supplied this
+ * time, in the same problem taxonomy, so the distiller knows what this user
+ * CAN state when reminded.
+ */
+export const GOOD_TOOL = {
+  name: 'report',
+  description: 'What the clean prompt supplied that the previous, messy one lacked.',
+  parameters: {
+    type: 'object',
+    properties: {
+      strengths: {
+        type: 'array',
+        maxItems: 4,
+        items: {
+          type: 'object',
+          properties: {
+            kind: { type: 'string', description: 'same categories as problems: missing-constraints|ambiguous-goal|missing-context|wrong-scope|...' },
+            what: { type: 'string', description: 'one sentence: what the prompt included this time' },
+          },
+          required: ['kind', 'what'],
+        },
+      },
+      lesson: { type: 'string', description: 'one sentence, about the user: what they included the second time that made the difference' },
+    },
+    required: ['strengths', 'lesson'],
+  },
+}
+export const GOOD_SYSTEM_PROMPT = [
+  'You coach prompt writing inside DeepSeek Harness. The previous turn of this',
+  'conversation went badly (retries, tool errors, a correction).',
+  'This turn went well. Compare the two prompts and the trajectory: what did the user',
+  'INCLUDE this time that the earlier prompt lacked — a file path, a constraint,',
+  'a scope, an acceptance criterion, an example? Report 1-4 strengths in the same',
+  'categories used for problems, and ONE sentence about the user ("They fix',
+  'wandering by naming the target file up front."). If the clean turn was',
+  'trivially easy or merely a continuation, return an empty strengths list and',
+  'an empty lesson. Never praise; state facts. Reply in the language of the prompt.',
+].join('\n')
+
 export const ANALYSIS_SYSTEM_PROMPT = [
   'You are a strict but friendly prompt-engineering coach inside DeepSeek Harness.',
   'You are given ONE past user prompt plus a digest of everything that happened',
@@ -354,13 +434,23 @@ export const DIRECTIVE_SYSTEM_PROMPT = [
   '"continue" — that is fine; the conversation is the context).',
   'Directives must GENERALIZE across future tasks: never mention a specific',
   'task, file, feature, number, or test from one past prompt — describe the',
-  'habit and the compensation. Prefer the most frequent habits. 2-4 directives,',
-  'one sentence each, imperative mood, addressed to the agent. You are writing',
+  'habit and the compensation. One exception: when every piece of evidence for',
+  'a habit carries the same [workspace: name] tag, return that directive with',
+  '"workspace" set to exactly that name; it may then refer to that project\'s',
+  'layout ("check apps/web first"). Leave "workspace" out for everything else.',
+  'Prefer the most frequent habits. 2-4 directives,',
+  'ONE sentence each of at most 25 words (under 180 characters), imperative',
+  'mood, addressed to the agent. A directive that needs a second sentence is two',
+  'directives or too specific. You are writing',
   'the COMPLETE new set: keep existing directives that still hold (reworded if',
   'sharper), drop ones that were one-off, add what is missing. No preamble.',
 ].join('\n')
 
-export function buildDirectiveUserText(profile, recentReports = []) {
+export function buildDirectiveUserText(profile, recentReports = [], { labelOf = workspaceLabel } = {}) {
+  const tagOf = (cwd) => {
+    const label = typeof cwd === 'string' && cwd.length > 0 ? labelOf(cwd) : ''
+    return label.length > 0 ? '[workspace: ' + label + '] ' : ''
+  }
   const lines = ['=== RECURRING PROMPT HABITS (kind, times seen, latest example) ===']
   const patterns = Array.isArray(profile?.patterns) ? profile.patterns.slice(0, 12) : []
   if (patterns.length === 0) lines.push('(none yet)')
@@ -373,9 +463,27 @@ export function buildDirectiveUserText(profile, recentReports = []) {
   if (corrections.length > 0) {
     lines.push('', '=== RECENT CORRECTIONS (prompt → what the user said next) ===')
     for (const report of corrections) {
-      lines.push('- "' + clipSafe(String(report.promptExcerpt ?? ''), 120) + '" → "' + clipSafe(report.followUp, 200) + '"')
+      lines.push('- ' + tagOf(report.cwd) + '"' + clipSafe(String(report.promptExcerpt ?? ''), 120) + '" → "' + clipSafe(report.followUp, 200) + '"')
     }
   }
+  const lessons = (Array.isArray(recentReports) ? recentReports : [])
+    .filter((report) => typeof report?.lesson === 'string' && report.lesson.length > 0)
+    .slice(-5)
+  if (lessons.length > 0) {
+    lines.push('', '=== WHAT WORKED (a clean prompt right after a messy turn — what the user included this time) ===')
+    for (const report of lessons) {
+      lines.push('- ' + tagOf(report.cwd) + '"' + clipSafe(String(report.promptExcerpt ?? ''), 120) + '": ' + clipSafe(report.lesson, 300))
+    }
+  }
+  const byWorkspace = new Map()
+  for (const report of Array.isArray(recentReports) ? recentReports : []) {
+    const label = typeof report?.cwd === 'string' && report.cwd.length > 0 ? labelOf(report.cwd) : ''
+    if (label.length > 0) byWorkspace.set(label, (byWorkspace.get(label) ?? 0) + 1)
+  }
+  if (byWorkspace.size > 0) {
+    lines.push('', '=== WORKSPACES IN THE RECENT ANALYSES (name, analyses) ===')
+    for (const [label, count] of byWorkspace) lines.push('- ' + label + ' (' + count + ')')
+  }
   const rules = Array.isArray(profile?.styleRules) ? profile.styleRules.filter((rule) => typeof rule?.rule === 'string' && rule.rule.length > 0) : []
   if (rules.length > 0) {
     lines.push('', '=== STYLE RULES THE USER CONFIRMED ===')
@@ -384,9 +492,9 @@ export function buildDirectiveUserText(profile, recentReports = []) {
   const existing = Array.isArray(profile?.directives) ? profile.directives.filter((entry) => typeof entry?.text === 'string' && entry.text.length > 0) : []
   if (existing.length > 0) {
     lines.push('', '=== CURRENT DIRECTIVES (keep the ones that still hold) ===')
-    for (const entry of existing) lines.push('- ' + clipSafe(entry.text, DIRECTIVE_MAX_CHARS))
+    for (const entry of existing) lines.push('- ' + clipDirective(entry.text) + (typeof entry.workspace === 'string' && entry.workspace.length > 0 ? ' [workspace: ' + labelOf(entry.workspace) + ']' : ''))
   }
-  lines.push('', 'Write 2-4 directives for the agent about this user.')
+  lines.push('', 'Write 2-4 directives for the agent about this user. A habit the user has', 'shown they can fix themselves is still worth a directive: the agent should', 'compensate for it when it is missing, not ask.')
   return lines.join('\n')
 }
 
@@ -405,30 +513,42 @@ export function classifyDirectives(text) {
   const kept = []
   const rejected = []
   for (const item of raw) {
-    if (typeof item !== 'string') continue
-    const value = clipSafe(item.trim(), DIRECTIVE_MAX_CHARS)
-    const key = value.toLowerCase()
+    // Both shapes are accepted: a bare sentence, or { text, workspace? }.
+    const source = typeof item === 'string' ? item : (item !== null && typeof item === 'object' && typeof item.text === 'string' ? item.text : null)
+    if (source === null) continue
+    const value = clipDirective(source)
+    const workspace = typeof item === 'object' && item !== null && typeof item.workspace === 'string' && item.workspace.trim().length > 0
+      ? clipSafe(item.workspace.trim(), 200)
+      : undefined
+    const key = (workspace ?? '') + '\n' + value.toLowerCase()
     if (value.length === 0 || seen.has(key)) continue
     seen.add(key)
     if (ASKS_USER_RE.test(value)) {
       rejected.push(value)
       continue
     }
-    kept.push(value)
+    kept.push(workspace === undefined ? { text: value } : { text: value, workspace })
     if (kept.length >= 4) break
   }
   return { kept, rejected }
 }
 
 /**
- * The system-prompt section: what the agent is told about this user.
- * '' when nothing is enabled (an empty section contributes nothing).
+ * The system-prompt section: what the agent is told about this user, plus the
+ * ids of the directives that actually made it into the text (the directive
+ * cap and the character budget can drop enabled ones). `text` is '' when
+ * nothing is enabled (an empty section contributes nothing).
  */
-export function renderSteeringSection(profile) {
-  const enabled = (Array.isArray(profile?.directives) ? profile.directives : [])
+export function buildSteeringSection(profile, { cwd } = {}) {
+  const here = typeof cwd === 'string' && cwd.length > 0 ? cwd : null
+  const scopeOf = (entry) => (typeof entry.workspace === 'string' && entry.workspace.length > 0 ? entry.workspace : null)
+  const candidates = (Array.isArray(profile?.directives) ? profile.directives : [])
     .filter((entry) => entry !== null && typeof entry === 'object' && entry.enabled !== false && entry.status !== 'retired'
       && typeof entry.text === 'string' && entry.text.trim().length > 0)
-  if (enabled.length === 0) return ''
+    .filter((entry) => scopeOf(entry) === null || scopeOf(entry) === here)
+  // This workspace's own directives first: they are the more specific ones.
+  const enabled = [...candidates.filter((entry) => scopeOf(entry) !== null), ...candidates.filter((entry) => scopeOf(entry) === null)]
+  if (enabled.length === 0) return { text: '', ids: [] }
   const header = [
     '## About this user (learned by Tacit from their past prompts)',
     'This user tends to leave the following unsaid. Compensate silently when the',
@@ -436,14 +556,21 @@ export function renderSteeringSection(profile) {
     'the prompt always win over these notes.',
   ]
   const lines = [...header]
+  const ids = []
   let length = lines.join('\n').length
   for (const entry of enabled.slice(0, MAX_DIRECTIVES)) {
-    const line = '- ' + clipSafe(entry.text.trim(), DIRECTIVE_MAX_CHARS)
+    const line = '- ' + clipDirective(entry.text)
     if (length + line.length + 1 > STEERING_MAX_CHARS) break
     lines.push(line)
+    if (typeof entry.id === 'string') ids.push(entry.id)
     length += line.length + 1
   }
-  return lines.length > header.length ? lines.join('\n') : ''
+  return lines.length > header.length ? { text: lines.join('\n'), ids } : { text: '', ids: [] }
+}
+
+/** The steering section text alone. */
+export function renderSteeringSection(profile, options = {}) {
+  return buildSteeringSection(profile, options).text
 }
 
 /** Build the distillation user text from verbatim rejected-improvement reasons. */
@@ -653,6 +780,27 @@ const clipText = (value, max) => {
 }
 
 /** Shape a parsed analysis object into a report (falls back gracefully). */
+/** Shape a good-prompt call into a report: no problems, the original prompt kept, the lesson as explanation. */
+export function normalizeGoodReport(parsed, { turn, time, model, prompt }) {
+  const raw = parsed !== null && typeof parsed === 'object' ? parsed : {}
+  const strengths = (Array.isArray(raw.strengths) ? raw.strengths : [])
+    .filter((item) => item !== null && typeof item === 'object' && typeof item.what === 'string' && item.what.trim().length > 0)
+    .slice(0, 4)
+    .map((item) => ({ kind: clipText(typeof item.kind === 'string' ? item.kind : 'general', 60) || 'general', what: clipText(item.what, 600) }))
+  const lesson = typeof raw.lesson === 'string' ? clipText(raw.lesson.trim(), 300) : ''
+  return reportSchema.parse({
+    ok: true,
+    turn,
+    time,
+    model,
+    problems: [],
+    improvedPrompt: typeof prompt === 'string' ? clipText(prompt, 4000) : '',
+    explanation: lesson,
+    strengths,
+    lesson,
+  })
+}
+
 export function normalizeReport(parsed, { turn, time, model, rawText }) {
   if (parsed === null) {
     return {
@@ -729,9 +877,16 @@ export function aggregateProfile(prev, report, maxPatterns, options = {}) {
         rejected: counterOf(pattern, 'rejected'),
         verified: counterOf(pattern, 'verified'),
         unverified: counterOf(pattern, 'unverified'),
+        resolved: counterOf(pattern, 'resolved'),
       })
     }
   }
+  // A good-prompt report says which habits the user overcame on their own this time.
+  for (const strength of Array.isArray(report?.strengths) ? report.strengths : []) {
+    if (strength === null || typeof strength !== 'object') continue
+    const current = patterns.get(normalizeKind(strength.kind))
+    if (current !== undefined) current.resolved += 1
+  }
   const problems = Array.isArray(report?.problems) ? report.problems : []
   for (const problem of problems) {
     if (problem === null || typeof problem !== 'object') continue
@@ -745,6 +900,7 @@ export function aggregateProfile(prev, report, maxPatterns, options = {}) {
       rejected: 0,
       verified: 0,
       unverified: 0,
+      resolved: 0,
     }
     current.count += 1
     if (typeof problem.what === 'string' && problem.what.length > 0) current.lastExample = problem.what.slice(0, 200)

package/lib/index.js

@@ -80,6 +80,19 @@ export function apply(ctx, config) {
     if (typeof off === 'function') ctx.effect(() => off, 'tacit: pre-step enrichment')
   }
 
+  // One line so an audit can tell from the logs alone that Tacit is loaded
+  // and what it is currently injecting.
+  try {
+    const cfg = effectiveConfig()
+    const directives = store.profile().directives
+    const count = (status) => directives.filter((entry) => entry.status === status).length
+    console.info('[tacit] loaded — directives: ' + count('active') + ' active, ' + count('candidate') + ' candidates, '
+      + count('retired') + ' retired; steering ' + (cfg.steerAgent ? 'on' : 'off') + '; auto-analysis '
+      + (cfg.autoAnalyze ? 'on (cap ' + cfg.autoDailyBudget + '/day)' : 'off'))
+  } catch {
+    // Logging must never keep the plugin from loading.
+  }
+
   ctx.effect(() => () => {
     // Nothing to flush: all writes are atomic and complete at call time.
   }, 'tacit: dispose')

package/lib/routes.js

@@ -126,7 +126,7 @@ export function registerWebRoutes(ctx, service) {
       }))
     }
 
-    route('POST', '/api/tacit/state', () => service.getState())
+    route('POST', '/api/tacit/state', (body) => service.getState(body))
     route('POST', '/api/tacit/reports', (body) => service.getReports(body))
     route('POST', '/api/tacit/history', (body) => service.listHistory(body))
     route('POST', '/api/tacit/analyze', (body) => service.analyzeTurn(body))

package/lib/schema.js

@@ -59,6 +59,10 @@ export const Config = z.preprocess((v) => v ?? {}, z.object({
   directiveTrialTurns: z.number().default(10),
   /** A candidate retires when the messy-turn rate during its trial exceeds the baseline by more than this. */
   directiveWorseBy: z.number().default(0.15),
+  /** Bootstrap analyses run at once (1 = one after another; same calls, less waiting). */
+  bootstrapConcurrency: z.number().default(1),
+  /** Also learn from a clean turn that follows a messy one (what the user included the second time). Automatic, capped. */
+  learnFromGood: z.boolean().default(true),
 }))
 
 /**
@@ -82,6 +86,8 @@ const configPatchSchema = z.object({
   enrichPrompts: z.boolean().optional(),
   directiveTrialTurns: z.number().optional(),
   directiveWorseBy: z.number().optional(),
+  bootstrapConcurrency: z.number().optional(),
+  learnFromGood: z.boolean().optional(),
 })
 
 // ── Trajectory projection ──────────────────────────────────────────────────
@@ -160,6 +166,12 @@ export const reportSchema = z.object({
   trigger: z.string().default('manual'),
   /** The user's next message when it triggered the analysis (clipped). */
   followUp: z.string().optional(),
+  /** Absolute workspace directory of the conversation, when the harness knew it. */
+  cwd: z.string().optional(),
+  /** trigger 'good' only: what the clean prompt supplied that the messy one before it lacked. */
+  strengths: z.array(z.object({ kind: z.string(), what: z.string() })).optional(),
+  /** trigger 'good' only: the one-sentence lesson fed to the distiller. */
+  lesson: z.string().optional(),
 })
 
 /**
@@ -178,6 +190,8 @@ export const patternCountersSchema = z.object({
   verified: z.number().int().default(0),
   /** Times the next turn's outcome was same/worse than the baseline. */
   unverified: z.number().int().default(0),
+  /** Times a clean prompt right after a messy turn showed the user supplying this themselves. */
+  resolved: z.number().int().default(0),
 })
 
 /** One distilled durable style rule (from rejected-improvement reasons). */
@@ -219,6 +233,8 @@ const directiveSchema = z.object({
   status: z.enum(['candidate', 'active', 'retired']).default('active'),
   trial: directiveTrialSchema.optional(),
   retiredReason: z.string().optional(),
+  /** Absolute workspace directory this directive is limited to; absent = every conversation. */
+  workspace: z.string().optional(),
 })
 
 /** The persistent user-wide mistake profile. */
@@ -257,7 +273,7 @@ export const statsArgSchema = z.object({
 
 export const directivesArgSchema = z.discriminatedUnion('action', [
   z.object({ action: z.literal('toggle'), id: z.string().min(1).max(64), enabled: z.boolean() }),
-  z.object({ action: z.literal('add'), text: z.string().min(1).max(300) }),
+  z.object({ action: z.literal('add'), text: z.string().min(1).max(300), workspace: z.string().max(1000).optional() }),
   z.object({ action: z.literal('remove'), id: z.string().min(1).max(64) }),
 ])