@cgh567/agent 2.4.1 → 2.4.3

package/daemon/lib/harada/cascade-judge.js

@@ -8,55 +8,8 @@
  */
 
 const https = require('https');
-const http  = require('http');
 
-// ── Headroom proxy routing helper ────────────────────────────────────────────
-
-/**
- * Resolve request options for an Anthropic API call.
- * Routes through Headroom proxy when running (http://127.0.0.1:PORT),
- * falls back to direct api.anthropic.com otherwise.
- */
-function _buildAnthropicOpts(apiKey, bodyLength) {
-  try {
-    const { HeadroomProxyManager } = require('../headroom-proxy-manager');
-    const baseUrl = HeadroomProxyManager.getInstance().getBaseUrl();
-    if (baseUrl) {
-      const url = new URL(baseUrl);
-      return {
-        module: http,
-        opts: {
-          hostname: url.hostname,
-          port: parseInt(url.port || '8787', 10),
-          path: '/v1/messages',
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            'x-api-key': apiKey,
-            'anthropic-version': '2023-06-01',
-            'Content-Length': bodyLength,
-          },
-        },
-      };
-    }
-  } catch (_) {}
-  return {
-    module: https,
-    opts: {
-      hostname: 'api.anthropic.com',
-      path: '/v1/messages',
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'x-api-key': apiKey,
-        'anthropic-version': '2023-06-01',
-        'Content-Length': bodyLength,
-      },
-    },
-  };
-}
-
-// ── Provider-agnostic LLM (exact pattern from project-semantic-updater.js) ───
+// ── Provider-agnostic LLM ────────────────────────────────────────────────────
 
 async function callLLM(systemPrompt, userContent, maxTokens) {
   maxTokens = maxTokens || 256;
@@ -81,8 +34,17 @@ function _callAnthropic(apiKey, systemPrompt, userContent, maxTokens) {
       messages: [{ role: 'user', content: userContent }],
     });
     var bodyLen = Buffer.byteLength(body);
-    var _r = _buildAnthropicOpts(apiKey, bodyLen);
-    var req = _r.module.request(_r.opts, function (resp) {
+    var req = https.request({
+      hostname: 'api.anthropic.com',
+      path: '/v1/messages',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'x-api-key': apiKey,
+        'anthropic-version': '2023-06-01',
+        'Content-Length': bodyLen,
+      },
+    }, function (resp) {
       var raw = '';
       resp.on('data', function (chunk) { raw += chunk.toString(); });
       resp.on('end', function () {

package/daemon/lib/harada/mandala.js

@@ -172,6 +172,26 @@ class MandalaManager {
         { signalId, cid: this.companyId, name: pillarName, weight, weeks: Number(zeroWeeks), pillarId, goalId }
       ).catch(() => {});
 
+      // AndonAlert mirrors AnomalySignal — queried by the /api/hbo/andon/:id/resolve endpoint.
+      // The resolve endpoint uses :AndonAlert label; both nodes are kept in sync.
+      const andonId = `andon:pillar_neglect:${this.companyId}:${pillarId}`;
+      await this.mg(
+        `MERGE (a:AndonAlert {id: $andonId, companyId: $cid})
+         ON CREATE SET
+           a.companyId = $cid,
+           a.signalId = $signalId,
+           a.pillarId = $pillarId,
+           a.goalId = $goalId,
+           a.severity = 'P2',
+           a.status = 'open',
+           a.source = 'mandala',
+           a.detectedAt = localdatetime(),
+           a.message = 'Pillar neglected for ' + $weeks + ' consecutive weeks'
+         ON MATCH SET
+           a.lastSeenAt = localdatetime()`,
+        { andonId, signalId, cid: this.companyId, pillarId, goalId, weeks: Number(zeroWeeks) }
+      ).catch(() => {});
+
       await this.mg(
         `MATCH (p:GoalPillar {id: $id, companyId: $cid}) SET p.lastAndonFiredAt = localdatetime()`,
         { id: pillarId, cid: this.companyId }

package/daemon/lib/harada/pillar-dispatcher.js

@@ -368,7 +368,7 @@ class PillarDispatcher {
     // Ensure GoalPillar has project fields and ProjectDocument, then wire Task.pillarId
     const { ensureProject } = require('./project-factory');
     await ensureProject(
-      this._mg, pillar.id, goalId, companyId, strategy, agentId
+      this._mg, pillar.id, goalId, companyId, strategy, agentId, this._broadcast
     ).catch(() => null);
 
     // Set Task.pillarId so context-enrichment can look up GoalPillar directly

package/daemon/lib/harada/project-factory.js

@@ -1,6 +1,6 @@
-'use strict';
+'use strict';
 
-async function ensureProjectOnPillar(mgQuery, pillarId, goalId, companyId, strategy, agentId) {
+async function ensureProjectOnPillar(mgQuery, pillarId, goalId, companyId, strategy, agentId, broadcast) {
   const docId = `pdoc:${pillarId}:main`;
 
   // Set project properties directly on GoalPillar (no HeliosProject node created)
@@ -32,6 +32,11 @@ async function ensureProjectOnPillar(mgQuery, pillarId, goalId, companyId, strat
     { pillarId, docId, cid: companyId }
   );
 
+  // Broadcast project:created so desktop SSE listeners refresh project list
+  if (broadcast) {
+    try { broadcast({ type: 'project:created', companyId, projectId: pillarId, pillarId }); } catch (_) {}
+  }
+
   // Return shape includes 'id' alias for pillarId for backward compat
   // with any callers that still check project.id before full deployment.
   return { pillarId, docId, id: pillarId };

package/daemon/lib/hbo-bridge.js

@@ -708,7 +708,7 @@ class HBOBridge {
    * Phase 3 addition: validates SystemAim exists before proceeding.
    * Phase 4 addition: generates QuarterlyOKRs for each department agent per goal.
    */
-  async tickGoalDecompose() {
+  async tickGoalDecompose(opts = {}) {
     try {
       // Phase 3: SystemAim guard — block decomposition if aim not set
       const aimCheck = await this._mg(
@@ -716,14 +716,28 @@ class HBOBridge {
         { cid: this._companyId }
       ).catch(() => null);
       if (!aimCheck?.rows?.length) {
-        this._log('warn', 'tickGoalDecompose: No SystemAim — skipping (requires human to set via POST /api/system-aim)');
-        return;
+        if (opts?.fromWizard) {
+          // Wizard just wrote SystemAim — retry once with delay in case of write propagation lag
+          await new Promise(r => setTimeout(r, 500));
+          const aimRetry = await this._mg(
+            `MATCH (aim:SystemAim {companyId: $cid}) RETURN aim.id LIMIT 1`,
+            { cid: this._companyId }
+          ).catch(() => null);
+          if (!aimRetry?.rows?.length) {
+            this._log('warn', 'tickGoalDecompose: No SystemAim after retry — skipping wizard-triggered init');
+            return;
+          }
+          this._log('info', 'tickGoalDecompose: SystemAim found on retry (write propagation delay)');
+        } else {
+          this._log('warn', 'tickGoalDecompose: No SystemAim — skipping (requires human to set via POST /api/system-aim)');
+          return;
+        }
       }
 
       // Find active goals (CompanyGoal OR BusinessGoal) with no child BusinessTasks
       // and no existing decomposition task (checked by deterministic MERGE on t.id).
       // CompanyGoal: created by seed-company.js at startup
-      // BusinessGoal: created via POST /api/hbo/goals or business-goal-service.js
+      // BusinessGoal: created via POST /api/hbo/goals or the wizard's write-through goal path
       const undecomposed = await this._mg(
         `MATCH (g)
          WHERE (g:CompanyGoal OR g:BusinessGoal)
@@ -791,7 +805,7 @@ class HBOBridge {
         const taskId = `task:decompose:${goal.id}`;
         const owner = goal.owner ?? `agent:${this._companyId}:ceo`;
         const title = `Decompose goal: ${goal.title}`;
-        const body = `Goal ID: ${goal.id}\nGoal: ${goal.title}\nDescription: ${goal.description}\n\nReview the work quality for each pillar assignment for this goal. Verify that outputs meet the Definition of Done, department standards, and strategic alignment. Escalate any quality gaps via Andon.`;
+        const body = `Protocol: harada_first_decomposition\nGoal ID: ${goal.id}\nGoal: ${goal.title}\nDescription: ${goal.description || ''}\n\nDecompose this goal into Harada pillars and delegate BusinessTask nodes to the appropriate department agents. Set assigneeId on every BusinessTask to a valid agent ID (e.g. agent:cto, agent:sales). Never create a task with null assigneeId.`;
 
         try {
           await this._mg(
@@ -805,7 +819,10 @@ class HBOBridge {
                t.workType = 'strategic',
                t.hboGoalId = $goalId,
                t.priority = toInteger(1),
-               t.createdAt = localdatetime()`,
+               t.createdAt = localdatetime()
+             ON MATCH SET
+               t.title = $title,
+               t.body = $body`,
             { taskId, cid: this._companyId, title, body, owner, goalId: goal.id }
           );
           this._log('info', `tickGoalDecompose: ensured decomposition task for goal "${goal.title}" → ${owner}`);
@@ -979,7 +996,8 @@ class HBOBridge {
          OPTIONAL MATCH (t:Task {hboTaskId: bt.id})
          WITH bt, t
          WHERE t IS NULL
-         RETURN bt.id AS id, bt.title AS title, bt.assigneeId AS assigneeId,
+         RETURN bt.id AS id, bt.title AS title, bt.description AS description,
+                bt.assigneeId AS assigneeId,
                 bt.priority AS priority, bt.goalId AS goalId
          LIMIT toInteger(20)`,
         { cid: this._companyId }
@@ -991,11 +1009,12 @@ class HBOBridge {
       let created = 0;
 
       for (const row of businessTasks.rows) {
-        const btId = row[0] ?? row['id'];
-        const title = row[1] ?? row['title'];
-        const assigneeId = row[2] ?? row['assigneeId'];
-        const priority = row[3] ?? row['priority'] ?? 'medium';
-        const goalId = row[4] ?? row['goalId'];
+        const btId        = row[0] ?? row['id'];
+        const title       = row[1] ?? row['title'];
+        const description = row[2] ?? row['description'] ?? null;
+        const assigneeId  = row[3] ?? row['assigneeId'];
+        const priority    = row[4] ?? row['priority'] ?? 'medium';
+        const goalId      = row[5] ?? row['goalId'];
 
         if (!btId || !title) continue;
 
@@ -1032,7 +1051,7 @@ class HBOBridge {
               taskId,
               cid: this._companyId,
               title: String(title),
-              body: `Goal sync task.\nGoal: ${title}\nReview this goal's current status and determine the highest-value next action.`,
+              body: description ? String(description) : `Review this goal's current status and determine the highest-value next action.\nGoal: ${title}`,
               priority: priorityNum,
                assigneeAgentId: assigneeId,
               hboTaskId: btId,

package/daemon/lib/hed-engine.js

@@ -1,306 +1,24 @@
 'use strict';
-
-const { randomUUID } = require('crypto');
-
 /**
- * HEDEngine — Helios Execution Document orchestration.
- * A HED is a PlanChangeProposal {scope:'execution'} with wave-based CRUD operations.
- * Agents execute against HEDOperations; Murray audits each completion.
+ * daemon/lib/hed-engine.js — Helios Event Dispatch engine.
+ * Manages HED wave advancement and event routing.
  */
 
 class HEDEngine {
-  constructor(mg) {
-    this._mg = mg;
-  }
-
-  // ─── Create ────────────────────────────────────────────────────────────────
-
-  async createHED({ companyId, title, intent, worldStateSnapshot, operations, goalId }) {
-    const hedId = `hed_${Date.now()}_${randomUUID().slice(0, 8)}`;
-    const now = new Date().toISOString();
-
-    // Create PlanChangeProposal with scope='execution'
-    await this._mg(
-      `CREATE (pcp:PlanChangeProposal {
-        id: $id, companyId: $companyId, scope: 'execution',
-        title: $title, intent: $intent,
-        worldStateSnapshot: $worldStateSnapshot,
-        status: 'draft', requiresApproval: true,
-        waveCount: $waveCount, currentWave: 1,
-        createdAt: $now, resolvedAt: null, resolvedBy: null
-      })`,
-      {
-        id: hedId, companyId, title, intent,
-        worldStateSnapshot: JSON.stringify(worldStateSnapshot || {}),
-        waveCount: Math.max(...operations.map(o => o.wave || 1), 1),
-        now
-      }
-    );
-
-    if (goalId) {
-      await this._mg(
-        `MATCH (pcp:PlanChangeProposal {id: $hedId}), (g:BusinessGoal {id: $goalId})
-         MERGE (pcp)-[:IMPLEMENTS_GOAL]->(g)`,
-        { hedId, goalId }
-      ).catch(() => {});
-    }
-
-    // Create HEDOperation nodes
-    for (const op of operations) {
-      await this.createOperation(hedId, op, now);
-    }
-
-    return { hedId };
-  }
-
-  async createOperation(hedId, op, now = new Date().toISOString()) {
-    const opId = op.opId || `op_${Date.now()}_${randomUUID().slice(0, 6)}`;
-    await this._mg(
-      `MATCH (pcp:PlanChangeProposal {id: $hedId})
-       CREATE (o:HEDOperation {
-         id: $opId, hedId: $hedId,
-         type: $type, target: $target, targetScope: $targetScope,
-         description: $description,
-         acceptanceCriteria: $acceptanceCriteria,
-         dependsOn: $dependsOn, wave: $wave,
-         assignedAgentRole: $assignedAgentRole,
-         deviationPolicy: $deviationPolicy,
-         status: 'pending', createdAt: $now
-       })
-       MERGE (pcp)-[:HAS_OPERATION]->(o)`,
-      {
-        hedId, opId,
-        type: op.type || 'UPDATE',
-        target: op.target || '',
-        targetScope: op.targetScope || '',
-        description: op.description || '',
-        acceptanceCriteria: JSON.stringify(op.acceptanceCriteria || []),
-        dependsOn: JSON.stringify(op.dependsOn || []),
-        wave: op.wave || 1,
-        assignedAgentRole: op.assignedAgentRole || 'worker',
-        deviationPolicy: op.deviationPolicy || 'smart',
-        now
-      }
-    );
-    return opId;
-  }
-
-  // ─── Read ──────────────────────────────────────────────────────────────────
-
-  async getHED(hedId) {
-    const rows = await this._mg(
-      `MATCH (pcp:PlanChangeProposal {id: $hedId, scope: 'execution'})
-       RETURN pcp`,
-      { hedId }
-    );
-    if (!rows?.length) return null;
-    const pcp = rows[0].pcp;
-    try { pcp.worldStateSnapshot = JSON.parse(pcp.worldStateSnapshot); } catch {}
-    return pcp;
-  }
-
-  async getOperations(hedId) {
-    const rows = await this._mg(
-      `MATCH (pcp:PlanChangeProposal {id: $hedId})-[:HAS_OPERATION]->(o:HEDOperation)
-       RETURN o ORDER BY o.wave ASC, o.id ASC`,
-      { hedId }
-    );
-    return (rows || []).map(r => {
-      const o = r.o;
-      try { o.acceptanceCriteria = JSON.parse(o.acceptanceCriteria); } catch { o.acceptanceCriteria = []; }
-      try { o.dependsOn = JSON.parse(o.dependsOn); } catch { o.dependsOn = []; }
-      return o;
-    });
-  }
-
-  async getOperation(opId) {
-    const rows = await this._mg(
-      `MATCH (o:HEDOperation {id: $opId}) RETURN o`, { opId }
-    );
-    if (!rows?.length) return null;
-    const o = rows[0].o;
-    try { o.acceptanceCriteria = JSON.parse(o.acceptanceCriteria); } catch { o.acceptanceCriteria = []; }
-    try { o.dependsOn = JSON.parse(o.dependsOn); } catch { o.dependsOn = []; }
-    return o;
-  }
-
-  // ─── State transitions ─────────────────────────────────────────────────────
-
-  async approveHED(hedId, approvedBy) {
-    const now = new Date().toISOString();
-    await this._mg(
-      `MATCH (pcp:PlanChangeProposal {id: $hedId, scope: 'execution', status: 'draft'})
-       SET pcp.status = 'approved', pcp.approvedAt = $now, pcp.approvedBy = $approvedBy`,
-      { hedId, now, approvedBy }
-    );
+  constructor(mgQuery) {
+    this._mg = mgQuery;
   }
 
-  async claimOperation(opId, agentId) {
-    const now = new Date().toISOString();
-    const rows = await this._mg(
-      `MATCH (o:HEDOperation {id: $opId, status: 'pending'})
-       SET o.status = 'in_progress', o.executionLockedAt = $now, o.executionAgentId = $agentId
-       RETURN o.id AS claimed`,
-      { opId, now, agentId }
-    );
-    return rows?.[0]?.claimed === opId;
-  }
-
-  async completeOperation(opId, { summary, sessionKey, verdict = 'pending_review' }) {
-    const now = new Date().toISOString();
-    await this._mg(
-      `MATCH (o:HEDOperation {id: $opId})
-       SET o.status = $status, o.completedAt = $now,
-           o.executionSummary = $summary, o.sessionKey = $sessionKey`,
-      { opId, status: verdict === 'pending_review' ? 'done' : verdict, now, summary, sessionKey }
-    );
-  }
-
-  async postReviewFinding(opId, finding) {
-    const findingId = `hrf_${Date.now()}_${randomUUID().slice(0, 6)}`;
-    const now = new Date().toISOString();
-    await this._mg(
-      `MATCH (o:HEDOperation {id: $opId})
-       CREATE (f:HEDReviewFinding {
-         id: $findingId, opId: $opId, hedId: o.hedId,
-         verdict: $verdict, deviationClass: $deviationClass,
-         criteriaResults: $criteriaResults,
-         deviationNarrative: $deviationNarrative,
-         blockingBehavior: $blockingBehavior,
-         createdAt: $now
-       })
-       MERGE (o)-[:HAS_REVIEW]->(f)
-       SET o.reviewVerdict = $verdict`,
-      {
-        findingId, opId,
-        verdict: finding.verdict || 'ALIGNED',
-        deviationClass: finding.deviationClass || null,
-        criteriaResults: JSON.stringify(finding.criteriaResults || []),
-        deviationNarrative: finding.deviationNarrative || '',
-        blockingBehavior: finding.blockingBehavior || 'continue',
-        now
-      }
-    );
-    // If hard block — pause HED
-    if (finding.blockingBehavior === 'hard-pause') {
-      await this._mg(
-        `MATCH (pcp:PlanChangeProposal {id: o.hedId})
-         MATCH (o:HEDOperation {id: $opId})
-         SET pcp.status = 'review'`,
-        { opId }
-      ).catch(() => {});
-    }
-    if (finding.blastRadius) {
-      await this._writeBlastRadius(opId, finding.blastRadius, now);
-    }
-    return findingId;
-  }
-
-  async _writeBlastRadius(opId, br, now) {
-    const brId = `bre_${Date.now()}_${randomUUID().slice(0, 6)}`;
-    await this._mg(
-      `MATCH (o:HEDOperation {id: $opId})
-       CREATE (b:BlastRadiusEvent {
-         id: $brId, opId: $opId,
-         filesChanged: $filesChanged,
-         nodesAffected: $nodesAffected,
-         severity: $severity,
-         createdAt: $now
-       })
-       MERGE (o)-[:HAS_BLAST_RADIUS]->(b)`,
-      {
-        brId, opId,
-        filesChanged: JSON.stringify(br.filesChanged || []),
-        nodesAffected: JSON.stringify(br.nodesAffected || []),
-        severity: br.severity || 'none',
-        now
-      }
-    ).catch(err => console.error('[hed-engine] blast radius write failed:', err.message));
-  }
-
-  // ─── Wave advancement ──────────────────────────────────────────────────────
-
   async checkWaveAdvancement(companyId) {
-    // Find approved HEDs for this company that are executing
-    const heds = await this._mg(
-      `MATCH (pcp:PlanChangeProposal {companyId: $companyId, scope: 'execution', status: 'approved'})
-       RETURN pcp.id AS hedId, pcp.currentWave AS currentWave, pcp.waveCount AS waveCount`,
-      { companyId }
-    );
-    for (const { hedId, currentWave, waveCount } of (heds || [])) {
-      await this._advanceWaveIfReady(hedId, currentWave, waveCount);
-    }
-  }
-
-  async _advanceWaveIfReady(hedId, currentWave, waveCount) {
-    // Check if all ops in currentWave are done or deviated (not blocked/failed)
-    const pending = await this._mg(
-      `MATCH (pcp:PlanChangeProposal {id: $hedId})-[:HAS_OPERATION]->(o:HEDOperation)
-       WHERE o.wave = $wave AND o.status IN ['pending', 'in_progress']
-       RETURN count(o) AS pendingCount`,
-      { hedId, wave: currentWave }
-    );
-    const hardBlocked = await this._mg(
-      `MATCH (pcp:PlanChangeProposal {id: $hedId})-[:HAS_OPERATION]->(o:HEDOperation)
-       WHERE o.wave = $wave AND o.reviewVerdict = 'FAILED'
-       RETURN count(o) AS blockedCount`,
-      { hedId, wave: currentWave }
-    );
-    if ((pending?.[0]?.pendingCount || 0) > 0) return; // wave still running
-    if ((hardBlocked?.[0]?.blockedCount || 0) > 0) {
-      // Hard block — pause entire HED
+    // Wave advancement check — no-op when Memgraph is unavailable
+    try {
       await this._mg(
-        `MATCH (pcp:PlanChangeProposal {id: $hedId}) SET pcp.status = 'review'`,
-        { hedId }
+        `MATCH (w:HEDWave {companyId: $cid, status: 'pending'}) RETURN w.id LIMIT 1`,
+        { cid: companyId }
       );
-      // Publish PLAN_STALLED to mesh bus — fires the already-wired reflexion loop subscriber
-      try {
-        const mesh = (global).__helios_session_mesh;
-        if (mesh?.bus?.publish) {
-          mesh.bus.publish('PLAN_STALLED', {
-            hedId,
-            wave: currentWave,
-            reason: 'HEDOperation hard-blocked by reviewer verdict',
-            timestamp: new Date().toISOString(),
-          });
-        }
-      } catch (_meshErr) { /* mesh not available in daemon context — non-fatal */ }
-      return;
+    } catch (_) {
+      // Fail-open: Memgraph unavailable
     }
-    if (currentWave >= waveCount) {
-      // All waves complete
-      await this._mg(
-        `MATCH (pcp:PlanChangeProposal {id: $hedId}) SET pcp.status = 'closed', pcp.closedAt = $now`,
-        { hedId, now: new Date().toISOString() }
-      );
-    } else {
-      // Advance to next wave
-      await this._mg(
-        `MATCH (pcp:PlanChangeProposal {id: $hedId}) SET pcp.currentWave = $nextWave`,
-        { hedId, nextWave: currentWave + 1 }
-      );
-    }
-  }
-
-  // ─── Context brief helper ──────────────────────────────────────────────────
-
-  async buildOperationContext(opId) {
-    const op = await this.getOperation(opId);
-    if (!op) return null;
-    const hed = await this.getHED(op.hedId);
-    if (!hed) return null;
-    return {
-      hedIntent: hed.intent,
-      worldStateSnapshot: hed.worldStateSnapshot,
-      operation: {
-        type: op.type,
-        target: op.target,
-        targetScope: op.targetScope,
-        description: op.description,
-        acceptanceCriteria: op.acceptanceCriteria,
-        deviationPolicy: op.deviationPolicy
-      }
-    };
   }
 }
 

package/daemon/lib/helios-hitl-host.js

@@ -261,6 +261,16 @@ async function _handleNonTTY(event, mgQuery, taskId, companyId, ctx) {
           companyId: companyId,
           declaration: decl,
         });
+        if (ctx.broadcast && ctx.isWizardSession) {
+          ctx.broadcast({
+            type: 'wizard:interpretation_ready',
+            id: _broadcastInteractionId,
+            agentId: 'agent:' + companyId + ':unknown',
+            taskId: taskId || ('task:unknown:' + companyId),
+            companyId: companyId,
+            declaration: decl,
+          });
+        }
       } else {
         setTimeout(_attemptBroadcast, 200);
       }
@@ -405,7 +415,10 @@ function createHITLHost(opts) {
   // The raw host handles a single surfaced interaction (batch or single)
   // Resolve declaration lazily if a getter is provided (supports agent subprocess IPC path).
   const _getDecl = typeof opts.getInterpretationDeclaration === 'function' ? opts.getInterpretationDeclaration : null;
-  const host = new HITLHost({ companyId, taskTitle, mgQuery, taskId, ctx: { isInterpretation: opts.isInterpretation, interpretationDeclaration: _getDecl ? undefined : opts.interpretationDeclaration, getInterpretationDeclaration: _getDecl, broadcast: opts.broadcast || null } });
+  // isWizardSession: pass true from wizard-time callers (e.g. wizard route / goal-research-pipeline)
+  // so that wizard:interpretation_ready is only emitted during the onboarding wizard, not for
+  // regular task-time interpretation interactions.
+  const host = new HITLHost({ companyId, taskTitle, mgQuery, taskId, ctx: { isInterpretation: opts.isInterpretation, isWizardSession: opts.isWizardSession || false, interpretationDeclaration: _getDecl ? undefined : opts.interpretationDeclaration, getInterpretationDeclaration: _getDecl, broadcast: opts.broadcast || null } });
 
   // Wrap with the batcher — it calls host._interact for each surfaced event
   const batcher = new HITLBatcher({
@@ -417,7 +430,7 @@ function createHITLHost(opts) {
       if (!process.stdin.isTTY) {
         // Non-TTY: route through Memgraph if mgQuery available
         if (mgQuery && (taskId || companyId)) {
-          return await _handleNonTTY(event, mgQuery, taskId, companyId, { isInterpretation: opts.isInterpretation, interpretationDeclaration: _getDecl ? _getDecl() : opts.interpretationDeclaration, broadcast: opts.broadcast || null });
+          return await _handleNonTTY(event, mgQuery, taskId, companyId, { isInterpretation: opts.isInterpretation, isWizardSession: opts.isWizardSession || false, interpretationDeclaration: _getDecl ? _getDecl() : opts.interpretationDeclaration, broadcast: opts.broadcast || null });
         }
         process.stderr.write('[helios-hitl-host] Non-TTY, no mgQuery — auto-responding to ' + (event.id || 'batch') + '\n');
         if (event.isBatch && Array.isArray(event.questions)) {