@pcircle/memesh 4.2.7 → 4.2.9

package/scripts/hooks/session-start.js

@@ -2,16 +2,17 @@
 
 import { createRequire } from 'module';
 import { spawn } from 'child_process';
-import { createHash } from 'crypto';
 import { homedir } from 'os';
 import { join } from 'path';
 import { pathToFileURL } from 'url';
 import { existsSync, readFileSync, unlinkSync, rmSync, appendFileSync, chmodSync } from 'fs';
 import {
+  buildReferenceContext,
   ensurePrivateDir,
   getDbPath,
   getMemeshDirFromDbPath,
   getProjectName,
+  importFromPluginRoot,
   isAgenticOrchestrationEnabled,
   isTrustedForAutoContext,
   readUpdateCheckCache,
@@ -373,7 +374,11 @@ function spawnFreshUpdateCheck(installedVersion) {
       {
         detached: true,
         stdio: 'ignore',
-        env: { ...process.env, MEMESH_UPDATE_REFRESH: '1' },
+        // `memesh status` already forces a fresh npm lookup (getUpdateCheck
+        // with preferFresh, the default) and rewrites the cache — so the
+        // spawn itself is the refresh. An earlier MEMESH_UPDATE_REFRESH='1'
+        // env var here had NO reader anywhere and did nothing; removed.
+        env: { ...process.env },
         windowsHide: true,
       },
     );
@@ -627,9 +632,10 @@ process.stdin.on('end', async () => {
       // throw `no such column: status`, hiding lessons from session-start
       // auto-context indefinitely.
       let lessonCount = 0;
+      let lessonEntities = [];
       try {
         const lessonRows = db.prepare(`
-          SELECT DISTINCT e.id, e.metadata
+          SELECT DISTINCT e.id, e.name, e.type, e.metadata
           FROM entities e
           JOIN tags t ON t.entity_id = e.id
           WHERE e.type = 'lesson_learned'
@@ -638,6 +644,7 @@ process.stdin.on('end', async () => {
           LIMIT 50
         `).all(projectTag).filter(entity => isTrustedForAutoContext(entity.metadata));
         lessonCount = lessonRows.length;
+        lessonEntities = lessonRows;
       } catch (err) {
         // Real query bug (typo, missing column on a schema older than v2.11)
         // — surface to stderr so a maintainer sees it on next session.
@@ -668,12 +675,126 @@ process.stdin.on('end', async () => {
         summary = parts.join(' · ');
       }
 
+      // --- Build the context actually injected into the model ---------
+      // The `summary` above is a human banner (counts only) and never
+      // reaches the model. This block is the real payload: the top-ranked
+      // entities with a short observation snippet each, sent via
+      // hookSpecificOutput.additionalContext.
+      //
+      // Lessons come first — they are the "don't repeat this mistake"
+      // signal and are the most expensive thing to rediscover.
+      //
+      // Budget: additionalContext is capped by Claude Code (10k chars). We
+      // stay far under that on purpose — session start should prime the
+      // model, not consume its working context. Snippets are truncated per
+      // observation and the whole block is hard-capped.
+      const MAX_SNIPPET = 160;
+      const MAX_CONTEXT_CHARS = 4000;
+
+      const memoryLines = [];
+      try {
+        // Only the entities we will actually render — the lesson query pulls
+        // up to 50 rows for the banner count, but at most 5 are injected, and
+        // this runs before the user's first turn. Bounded well under SQLite's
+        // 999-variable limit by construction (5 lessons + sessionLimit
+        // project + 5 recent).
+        const topLessons = lessonEntities.slice(0, 5);
+        const rankedIds = [
+          ...topLessons.map(e => e.id),
+          ...projectEntities.map(e => e.id),
+          ...recentEntities.map(e => e.id),
+        ];
+        const uniqueIds = [...new Set(rankedIds)];
+
+        // One query for every snippet — avoids N round-trips on the
+        // session-start hot path (this runs before the user's first turn).
+        const snippets = new Map();
+        if (uniqueIds.length > 0) {
+          const placeholders = uniqueIds.map(() => '?').join(',');
+          const obsRows = db.prepare(
+            `SELECT entity_id, content FROM observations
+             WHERE entity_id IN (${placeholders})
+             ORDER BY id ASC`
+          ).all(...uniqueIds);
+          for (const row of obsRows) {
+            // Keep the FIRST observation per entity: observations are
+            // append-only, so the first one is the defining statement and
+            // later ones are refinements.
+            if (snippets.has(row.entity_id)) continue;
+            const text = String(row.content ?? '').replace(/\s+/g, ' ').trim();
+            if (text) snippets.set(row.entity_id, text.slice(0, MAX_SNIPPET));
+          }
+        }
+
+        // Groups overlap by construction: a lesson tagged to this project
+        // is in lessonEntities AND projectEntities. Render each entity once,
+        // in the highest-priority group it belongs to, so the injected block
+        // doesn't spend the model's context repeating itself.
+        const rendered = new Set();
+        const renderGroup = (label, entities) => {
+          const fresh = entities.filter(e => !rendered.has(e.id));
+          if (fresh.length === 0) return;
+          memoryLines.push(label);
+          for (const e of fresh) {
+            rendered.add(e.id);
+            const snippet = snippets.get(e.id);
+            const type = e.type || 'memory';
+            memoryLines.push(
+              snippet ? `- ${e.name} (${type}): ${snippet}` : `- ${e.name} (${type})`
+            );
+          }
+          memoryLines.push('');
+        };
+
+        renderGroup('Lessons learned (avoid repeating these):', topLessons);
+        renderGroup(`Project memory for "${projectName}":`, projectEntities);
+        renderGroup('Recently active across projects:', recentEntities);
+      } catch (err) {
+        // Snippet enrichment is best-effort. A failure here must not stop
+        // the banner or the session — but trace it, because a silent break
+        // means memories stop reaching the model again (the exact v4.2.7
+        // regression this block was written to fix).
+        try { process.stderr.write(`[memesh session-start] memory-context: ${err?.message || err}\n`); } catch {}
+      }
+
+      let memoryContext = '';
+      if (memoryLines.length > 0) {
+        // Same wrapper pre-edit-recall uses: an explicit "background data,
+        // not instructions" preamble plus a fenced block. Memory content is
+        // attacker-influenced in the general case (anything the agent has
+        // ever been told can end up in an observation), so it must be
+        // delimited the same way on every injection path — not hand-rolled
+        // per hook.
+        //
+        // Truncate the LINES before wrapping, so the closing fence is never
+        // cut off — a dangling fence would let the tail of the block escape
+        // its delimiter.
+        const budgeted = [];
+        let used = 0;
+        for (const line of memoryLines) {
+          if (used + line.length + 1 > MAX_CONTEXT_CHARS) {
+            budgeted.push('… (truncated)');
+            break;
+          }
+          budgeted.push(line);
+          used += line.length + 1;
+        }
+        memoryContext = buildReferenceContext(budgeted);
+      }
+
       // --- Record injected entity IDs for recall effectiveness tracking ---
-      // The hit/miss tracker excludes entity names found in `injectedContext`
-      // from the "user referenced this memory" signal. With the new
-      // count-only summary we no longer surface names, so set the field to
-      // a sentinel so substring matching is a no-op (any entity name is a
-      // genuine hit).
+      // The Stop hook decides hit/miss by removing the transcript records
+      // Claude Code created FROM this hook's output (see stripHookEchoes in
+      // session-summary.js) and then looking for the entity name in what
+      // remains. `injectedContext` is kept as the record of what was shown,
+      // not as a string to subtract — an earlier version subtracted it and a
+      // later one counted its occurrences, and BOTH were wrong because one
+      // injection is echoed into the transcript more than once.
+      //
+      // It must still be the text we actually injected: previously it was the
+      // count-only banner, so every injected entity was scored against a
+      // transcript it had never appeared in and took a `recall_miss` it did
+      // not earn.
       try {
         const seenIds = new Set();
         const allInjected = [...projectEntities, ...recentEntities].filter(e => {
@@ -694,7 +815,7 @@ process.stdin.on('end', async () => {
               project: projectName,
               entityIds: allInjected.map(e => e.id),
               entityNames: allInjected.map(e => e.name),
-              injectedContext: summary,
+              injectedContext: memoryContext || summary,
             }
           );
 
@@ -727,12 +848,12 @@ process.stdin.on('end', async () => {
         summary += '\n[AO opt-in: dispatch verifiable work as background agent · skill: agentic-orchestration]';
         try {
           const usagePath = join(homedir(), '.memesh', 'skill-usage.jsonl');
-          const cwd = String(data?.cwd || process.cwd());
-          const cwdHashed = createHash('sha256').update(cwd).digest('hex').slice(0, 16);
+          // Only { ts, event } — an earlier `payload: { cwd_hashed }` was never
+          // read by summariseSkillUsage (counts by event name only), so it was
+          // write-only privacy-adjacent data. Removed.
           const line = JSON.stringify({
             ts: new Date().toISOString(),
             event: 'agentic_orchestration_banner_injected',
-            payload: { cwd_hashed: cwdHashed },
           }) + '\n';
           appendFileSync(usagePath, line);
           try { chmodSync(usagePath, 0o600); } catch { /* non-POSIX */ }
@@ -768,7 +889,7 @@ process.stdin.on('end', async () => {
         ? [...bannerLines.filter(l => l.length > 0), '', summary].join('\n')
         : summary;
 
-      output(finalMessage);
+      output(finalMessage, memoryContext);
     } finally {
       db.close();
     }
@@ -779,8 +900,8 @@ process.stdin.on('end', async () => {
       // F5: derive pluginRoot strictly from this file's location.
       // See `resolvePluginRoot` for the full reasoning.
       const pluginRoot = resolvePluginRoot(import.meta.url);
-      const dbMod = await import(join(pluginRoot, 'dist/db.js'));
-      const lifecycleMod = await import(join(pluginRoot, 'dist/core/lifecycle.js'));
+      const dbMod = await importFromPluginRoot(pluginRoot, 'dist/db.js');
+      const lifecycleMod = await importFromPluginRoot(pluginRoot, 'dist/core/lifecycle.js');
       dbMod.openDatabase();
       try {
         lifecycleMod.compressWeeklyNoise(dbMod.getDatabase());
@@ -813,6 +934,36 @@ process.stdin.on('end', async () => {
   }
 });
 
-function output(text) {
-  console.log(JSON.stringify({ systemMessage: text }));
+/**
+ * Emit the SessionStart hook payload.
+ *
+ * Two channels, two audiences — they are NOT interchangeable:
+ *
+ *   systemMessage      -> shown to the human in the terminal. Claude Code
+ *                         strips it from the model's context entirely
+ *                         (`normalizeAttachmentForAPI` returns [] for the
+ *                         `hook_system_message` attachment type).
+ *   hookSpecificOutput -> `additionalContext` IS injected into the model's
+ *      .additionalContext  context for the next turn. `SessionStart` is one of
+ *                         the nine events with a valid variant.
+ *
+ * Until v4.2.7 this hook only ever emitted `systemMessage`, so *nothing*
+ * memesh recalled at session start ever reached the model — the banner said
+ * "4 project + 5 recent memories" while the model received none of them.
+ * Worse, the Stop hook then marked every one of those entities as a
+ * `recall_miss` for not appearing in the transcript, so memories that were
+ * never shown were permanently penalised in ranking (see scoring.ts
+ * impactScore). Passing `memoryContext` closes that loop honestly.
+ *
+ * The shape is asserted by tests/helpers/hook-output-contract.ts.
+ */
+function output(text, memoryContext) {
+  const payload = { systemMessage: text };
+  if (memoryContext) {
+    payload.hookSpecificOutput = {
+      hookEventName: 'SessionStart',
+      additionalContext: memoryContext,
+    };
+  }
+  console.log(JSON.stringify(payload));
 }

package/scripts/hooks/session-summary.js

@@ -11,9 +11,11 @@ import { spawn } from 'child_process';
 import os from 'os';
 import { pathToFileURL } from 'url';
 import {
+  captureEntity,
   decideAutoUpdateHook,
   getMemeshDirFromDbPath,
   getProjectName,
+  importFromPluginRoot,
   isAutoCaptureEnabled,
   openHookDb,
   readUpdateCheckCache,
@@ -125,11 +127,23 @@ function parseTranscript(transcriptPath) {
         // the prior version) that signalled review fatigue more than
         // working logic.
       } catch {
-        // Skip malformed JSONL lines
+        // Skip malformed JSONL lines — benign, per-line, deliberately not traced.
       }
     }
-  } catch {
-    // Transcript unreadable — return empty results
+  } catch (err) {
+    // The transcript file itself could not be read, which empties this
+    // session's entire capture — filesEdited/errors/toolCallCount all return
+    // zero, so downstream `toolCallCount < 3` bails and no session insight,
+    // failure analysis or lesson is produced. An absent file is the normal
+    // "not written yet" case; anything else is a real fault worth a trace.
+    if (err?.code !== 'ENOENT') {
+      try {
+        process.stderr.write(
+          `[memesh session-summary] transcript ${transcriptPath} unreadable ` +
+            `(${err?.message || err}); session capture skipped this run.\n`,
+        );
+      } catch { /* stderr must never throw */ }
+    }
   }
 
   return { filesEdited: [...filesEdited], bashCommands, errorsEncountered, toolCallCount };
@@ -163,7 +177,6 @@ process.stdin.on('end', async () => {
     const sessionId = inputData.session_id || 'unknown';
     const transcriptPath = inputData.transcript_path;
     const cwd = inputData.cwd || process.cwd();
-    const stopReason = inputData.stop_reason || 'unknown';
     // Default-allow: when Claude Code's Stop payload omits
     // `was_in_agentic_loop` (it has been silently absent in production
     // for an unknown number of releases — symptom: zero session-insight
@@ -173,8 +186,18 @@ process.stdin.on('end', async () => {
     // (default-deny) and the hook silently never captured anything.
     const wasAgenticLoop = inputData.was_in_agentic_loop !== false;
 
-    // Guards: skip low-signal sessions
-    if (stopReason === 'user_interrupt') return exit0();
+    // Guards: skip low-signal sessions.
+    //
+    // A `stop_reason === 'user_interrupt'` guard used to live here, but
+    // Claude Code's Stop payload carries no `stop_reason` field — verified
+    // against the shipped cli.js bundle, whose Stop input is
+    // `{...base, hook_event_name:"Stop", stop_hook_active}` with no such key
+    // (the `stop_reason` that appears in the bundle is the Anthropic API
+    // message field, not a hook input). So the guard read `undefined`, was
+    // always false, and never skipped anything — a filter that looked active
+    // but did nothing, the exact sibling of the `was_in_agentic_loop` absence
+    // above. Removed; the `toolCallCount < 3` check below is the real
+    // low-signal filter.
     if (!wasAgenticLoop) return exit0();
     // Trace why we're skipping. Two failure modes:
     //   (a) transcript_path absent — schema flip, Claude Code stopped
@@ -211,7 +234,9 @@ process.stdin.on('end', async () => {
     // Open DB via shared helper — applies SCHEMA_SQL + status migration.
     // sqlite-vec is loaded separately because only this hook needs it
     // (for embedding-aware recall-effectiveness tracking).
-    const handle = openHookDb(process.env);
+    // { fts: true } guarantees the entities_fts table exists so captureEntity()
+    // can keep it in sync — session-insight memories must be FTS-recallable.
+    const handle = openHookDb(process.env, { fts: true });
     if (!handle) {
       // Native module unavailable (plugin-marketplace cache install with no
       // node_modules). Skip session-capture work, but still let the
@@ -251,17 +276,30 @@ process.stdin.on('end', async () => {
       // Build and store session memories
       const baseTags = ['source:auto-capture', `session:${sessionId}`, `project:${projectName}`];
 
-      const insertEntity = db.prepare('INSERT OR IGNORE INTO entities (name, type) VALUES (?, ?)');
-      const selectEntity = db.prepare('SELECT id FROM entities WHERE name = ?');
-      const insertObs = db.prepare('INSERT INTO observations (entity_id, content) VALUES (?, ?)');
-      const insertTag = db.prepare('INSERT OR IGNORE INTO tags (entity_id, tag) VALUES (?, ?)');
+      // Producer for pre-edit-recall's Strategy 1 (`file:<name>` tag lookup).
+      // That read path queries both the full basename and the extension-less
+      // form (`file:auth.ts` OR `file:auth`), but nothing ever WROTE these
+      // tags — on every real DB the query returned zero rows and the strategy
+      // was dead. Emitting both forms here lights it up: a memory captured while
+      // editing a file becomes findable the next time that file is edited.
+      // filesEdited already holds basenames (see parseTranscript).
+      function fileTagsFor(files) {
+        const tags = new Set();
+        for (const f of files) {
+          if (!f) continue;
+          tags.add(`file:${f}`);
+          const noExt = f.replace(/\.[^.]+$/, '');
+          if (noExt && noExt !== f) tags.add(`file:${noExt}`);
+        }
+        return [...tags];
+      }
 
+      // Delegate the write to the shared captureEntity() so entities land in
+      // entities_fts too. This copy used to insert entity + observations + tags
+      // only, skipping the FTS reindex the sibling hooks did — which left every
+      // session-insight memory unrecallable via the FTS keyword path.
       function storeMemory(name, type, observations, tags) {
-        insertEntity.run(name, type);
-        const row = selectEntity.get(name);
-        if (!row) return;
-        for (const obs of observations) insertObs.run(row.id, obs);
-        for (const tag of tags) insertTag.run(row.id, tag);
+        captureEntity(db, { name, type, observations, tags });
       }
 
       // Rule 1: File editing session summary
@@ -273,7 +311,7 @@ process.stdin.on('end', async () => {
             `Session edited ${filesEdited.length} file(s): ${filesEdited.join(', ')}`,
             `Total tool calls: ${toolCallCount}`,
           ],
-          baseTags
+          [...baseTags, ...fileTagsFor(filesEdited)]
         );
       }
 
@@ -286,7 +324,7 @@ process.stdin.on('end', async () => {
             `Fixed ${errorsEncountered.length} error(s) by editing ${filesEdited.join(', ')}`,
             ...errorsEncountered.slice(0, 3).map(e => `Error: ${e.slice(0, 100)}`),
           ],
-          [...baseTags, 'type:bugfix']
+          [...baseTags, 'type:bugfix', ...fileTagsFor(filesEdited)]
         );
       }
 
@@ -366,15 +404,16 @@ process.stdin.on('end', async () => {
             // Check if recall_hits column exists (v4.0+ migration)
             const colCheck = db.prepare("PRAGMA table_info(entities)").all();
             if (colCheck.some(c => c.name === 'recall_hits')) {
-              // Build a lowercase transcript text for matching
-              let transcriptText = readFileSync(transcriptPath, 'utf8').toLowerCase();
-
-              // FIX: Exclude injected context from hit detection to avoid pollution
-              // Remove the memorySummary that was injected at session start
-              const injectedContext = (injectedData.injectedContext || '').toLowerCase();
-              if (injectedContext) {
-                transcriptText = transcriptText.replace(injectedContext, '');
-              }
+              // Drop the records Claude Code created FROM our own hook
+              // output before matching. One SessionStart injection lands in
+              // the transcript 2+ times (hook_success + hook_additional_context),
+              // so any count-based discount depends on guessing an
+              // undocumented internal — get it wrong and every entity scores
+              // a hit instead of a miss. Structural removal is copy-count
+              // and encoding independent.
+              const sessionText = stripHookEchoes(readFileSync(transcriptPath, 'utf8')).toLowerCase();
+
+              // Hit/miss decision lives in `isRecallHit` (exported, unit-tested).
 
               const updateHit = db.prepare(
                 'UPDATE entities SET recall_hits = COALESCE(recall_hits, 0) + 1 WHERE id = ?'
@@ -387,7 +426,7 @@ process.stdin.on('end', async () => {
                 const name = (entityNames[i] || '').toLowerCase();
                 // Skip very short names to avoid false positives
                 if (name.length < 4) continue;
-                if (transcriptText.includes(name)) {
+                if (isRecallHit(sessionText, name)) {
                   updateHit.run(entityIds[i]);
                 } else {
                   updateMiss.run(entityIds[i]);
@@ -417,13 +456,13 @@ process.stdin.on('end', async () => {
         // F5: derive pluginRoot strictly from this file's location.
         // See `resolvePluginRoot` for the full reasoning.
         const pluginRoot = resolvePluginRoot(import.meta.url);
-        const configMod = await import(join(pluginRoot, 'dist/core/config.js'));
+        const configMod = await importFromPluginRoot(pluginRoot, 'dist/core/config.js');
         const config = configMod.readConfig();
 
         if (config.llm) {
-          const { openDatabase, closeDatabase } = await import(join(pluginRoot, 'dist/db.js'));
-          const { analyzeFailure } = await import(join(pluginRoot, 'dist/core/failure-analyzer.js'));
-          const { createLesson } = await import(join(pluginRoot, 'dist/core/lesson-engine.js'));
+          const { openDatabase, closeDatabase } = await importFromPluginRoot(pluginRoot, 'dist/db.js');
+          const { analyzeFailure } = await importFromPluginRoot(pluginRoot, 'dist/core/failure-analyzer.js');
+          const { createLesson } = await importFromPluginRoot(pluginRoot, 'dist/core/lesson-engine.js');
 
           openDatabase();
           try {
@@ -452,7 +491,7 @@ process.stdin.on('end', async () => {
     // logic and dream-history.json schema.
     try {
       const pluginRoot = resolvePluginRoot(import.meta.url);
-      const configMod = await import(join(pluginRoot, 'dist/core/config.js'));
+      const configMod = await importFromPluginRoot(pluginRoot, 'dist/core/config.js');
       const config = configMod.readConfig();
       maybeTriggerDream(projectName, config, pluginRoot);
     } catch (dreamErr) {
@@ -647,6 +686,79 @@ function countEpisodicEntities(projectName) {
  * the detached background runner. Pure side effect — no return value
  * used by callers.
  */
+/**
+ * Attachment record types Claude Code uses to persist a hook's own output
+ * into the transcript. Anything memesh injected reaches the transcript
+ * through one of these, so they must be removed before asking "did the
+ * session reference this memory?".
+ *
+ * Verified against Claude Code v2.1.19: ONE SessionStart injection lands in
+ * the transcript at least twice — once as `hook_success` (carrying the raw
+ * hook stdout) and once as `hook_additional_context` (the parsed payload).
+ */
+const HOOK_ECHO_ATTACHMENT_TYPES = new Set([
+  'hook_success',
+  'hook_additional_context',
+  'hook_system_message',
+]);
+
+/**
+ * Remove memesh's own injected text from a raw JSONL transcript.
+ *
+ * Counting occurrences and subtracting the injected copies does NOT work:
+ * it depends on knowing exactly how many times Claude Code echoes a hook
+ * payload, which is an undocumented internal that has already been observed
+ * at 2+ copies (and 16 in one real transcript). Guessing that constant is
+ * how "every entity is a miss" becomes "every entity is a hit" — equally
+ * useless, and invisible to a hand-built test fixture.
+ *
+ * Dropping the hook-echo records structurally is independent of both the
+ * copy count and the JSON escaping.
+ */
+export function stripHookEchoes(rawTranscript) {
+  const kept = [];
+  for (const line of String(rawTranscript ?? '').split('\n')) {
+    if (!line.trim()) continue;
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      // Unparseable line: keep it. Losing a line can only cause a false
+      // MISS (we under-count references), which is the safe direction —
+      // it never manufactures a hit the session did not earn.
+      kept.push(line);
+      continue;
+    }
+    const type = entry?.attachment?.type ?? entry?.type;
+    if (typeof type === 'string' && HOOK_ECHO_ATTACHMENT_TYPES.has(type)) continue;
+    kept.push(line);
+  }
+  return kept.join('\n');
+}
+
+/**
+ * Did the session actually USE the memory named `name`, or does the name only
+ * appear because memesh injected it at session start?
+ *
+ * The caller passes `sessionText` with memesh's own SessionStart injection
+ * already stripped structurally (see `stripHookEchoes` — matches on
+ * `attachment.type`, so it is independent of JSON escaping and of how many
+ * times Claude Code echoes one injection). That removal is what stops an
+ * injected name from scoring a false hit; once the echo is gone, a plain
+ * substring match is the whole test.
+ *
+ * (This replaced an earlier `transcript.replace(injectedBlob, '')` + match,
+ * which silently failed on JSON-encoded transcripts and scored every entity a
+ * hit — see the callsite comment.)
+ *
+ * Self-contained for its unit tests: lowercases both sides and ignores names
+ * shorter than 4 chars (too generic to match reliably).
+ */
+export function isRecallHit(sessionText, name) {
+  if (!name || name.length < 4) return false;
+  return String(sessionText ?? '').toLowerCase().includes(String(name).toLowerCase());
+}
+
 export function maybeTriggerDream(projectName, config, pluginRoot) {
   dreamTrigTrace('enter', { projectName, hasLlm: Boolean(config?.llm) });
   if (!projectName || projectName === 'unknown') {