@cleocode/cleo 2026.4.15 → 2026.4.17

package/dist/cli/index.js

@@ -9205,6 +9205,9 @@ var init_brain_schema = __esm({
         sourceSessionId: text("source_session_id"),
         // soft FK to sessions
         sourceType: text("source_type", { enum: BRAIN_OBSERVATION_SOURCE_TYPES }).notNull().default("agent"),
+        /** T383/T417: agent provenance — identifies the spawned agent that produced this observation. Null for legacy entries. */
+        agent: text("agent"),
+        // nullable — null for legacy observations
         contentHash: text("content_hash"),
         // SHA-256 prefix for dedup
         discoveryTokens: integer("discovery_tokens"),
@@ -9221,7 +9224,9 @@ var init_brain_schema = __esm({
         // T033: composite replaces single-col content_hash; see brain migration
         index("idx_brain_observations_content_hash_created_at").on(table.contentHash, table.createdAt),
         // T033: type + project compound filter optimization
-        index("idx_brain_observations_type_project").on(table.type, table.project)
+        index("idx_brain_observations_type_project").on(table.type, table.project),
+        // T417: agent provenance index for memory.find --agent filter
+        index("idx_brain_observations_agent").on(table.agent)
       ]
     );
     brainStickyNotes = sqliteTable(
@@ -10795,6 +10800,7 @@ var init_platform_paths = __esm({
 });
 
 // packages/core/src/paths.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
 import { homedir } from "node:os";
 import { dirname as dirname2, join as join4, resolve as resolve2 } from "node:path";
@@ -10826,6 +10832,10 @@ function getCleoDirAbsolute(cwd) {
   return resolve2(cwd ?? process.cwd(), cleoDir);
 }
 function getProjectRoot(cwd) {
+  const scope = worktreeScope.getStore();
+  if (scope !== void 0) {
+    return scope.worktreeRoot;
+  }
   if (process.env["CLEO_ROOT"]) {
     return process.env["CLEO_ROOT"];
   }
@@ -10988,13 +10998,14 @@ function getClaudeAgentsDir() {
 function getClaudeMemDbPath() {
   return process.env["CLAUDE_MEM_DB"] ?? join4(homedir(), ".claude-mem", "claude-mem.db");
 }
-var DEFAULT_AGENT_OUTPUTS_DIR;
+var worktreeScope, DEFAULT_AGENT_OUTPUTS_DIR;
 var init_paths = __esm({
   "packages/core/src/paths.ts"() {
     "use strict";
     init_src();
     init_errors3();
     init_platform_paths();
+    worktreeScope = new AsyncLocalStorage();
     DEFAULT_AGENT_OUTPUTS_DIR = ".cleo/agent-outputs";
   }
 });
@@ -17548,6 +17559,9 @@ var init_brain_accessor = __esm({
         if (params.sourceSessionId) {
           conditions.push(eq7(brainObservations.sourceSessionId, params.sourceSessionId));
         }
+        if (params.agent) {
+          conditions.push(eq7(brainObservations.agent, params.agent));
+        }
         let query = this.db.select().from(brainObservations).orderBy(desc2(brainObservations.createdAt));
         if (conditions.length > 0) {
           query = query.where(and5(...conditions));
@@ -25412,44 +25426,51 @@ __export(brain_retrieval_exports, {
 });
 import { createHash as createHash3 } from "node:crypto";
 async function searchBrainCompact(projectRoot, params) {
-  const { query, limit, tables, dateStart, dateEnd } = params;
+  const { query, limit, tables, dateStart, dateEnd, agent } = params;
   if (!query || !query.trim()) {
     return { results: [], total: 0, tokensEstimated: 0 };
   }
+  const effectiveTables = agent !== void 0 && agent !== null ? ["observations"] : tables;
   const searchResult = await searchBrain(projectRoot, query, {
     limit: limit ?? 10,
-    tables
+    tables: effectiveTables
   });
   let results = [];
-  for (const d of searchResult.decisions) {
-    const raw = d;
-    results.push({
-      id: d.id,
-      type: "decision",
-      title: d.decision.slice(0, 80),
-      date: (d.createdAt ?? raw["created_at"]) || ""
-    });
-  }
-  for (const p2 of searchResult.patterns) {
-    const raw = p2;
-    results.push({
-      id: p2.id,
-      type: "pattern",
-      title: p2.pattern.slice(0, 80),
-      date: (p2.extractedAt ?? raw["extracted_at"]) || ""
-    });
-  }
-  for (const l of searchResult.learnings) {
-    const raw = l;
-    results.push({
-      id: l.id,
-      type: "learning",
-      title: l.insight.slice(0, 80),
-      date: (l.createdAt ?? raw["created_at"]) || ""
-    });
+  if (!agent) {
+    for (const d of searchResult.decisions) {
+      const raw = d;
+      results.push({
+        id: d.id,
+        type: "decision",
+        title: d.decision.slice(0, 80),
+        date: (d.createdAt ?? raw["created_at"]) || ""
+      });
+    }
+    for (const p2 of searchResult.patterns) {
+      const raw = p2;
+      results.push({
+        id: p2.id,
+        type: "pattern",
+        title: p2.pattern.slice(0, 80),
+        date: (p2.extractedAt ?? raw["extracted_at"]) || ""
+      });
+    }
+    for (const l of searchResult.learnings) {
+      const raw = l;
+      results.push({
+        id: l.id,
+        type: "learning",
+        title: l.insight.slice(0, 80),
+        date: (l.createdAt ?? raw["created_at"]) || ""
+      });
+    }
   }
   for (const o of searchResult.observations) {
     const raw = o;
+    if (agent) {
+      const rowAgent = o.agent ?? raw["agent"] ?? null;
+      if (rowAgent !== agent) continue;
+    }
     results.push({
       id: o.id,
       type: "observation",
@@ -25663,7 +25684,15 @@ function classifyObservationType(text3) {
   return "discovery";
 }
 async function observeBrain(projectRoot, params) {
-  const { text: text3, title: titleParam, type: typeParam, project, sourceSessionId, sourceType } = params;
+  const {
+    text: text3,
+    title: titleParam,
+    type: typeParam,
+    project,
+    sourceSessionId,
+    sourceType,
+    agent
+  } = params;
   if (!text3 || !text3.trim()) {
     throw new Error("Observation text is required");
   }
@@ -25712,6 +25741,7 @@ async function observeBrain(projectRoot, params) {
     project: project ?? null,
     sourceSessionId: validSessionId,
     sourceType: sourceType ?? "agent",
+    agent: agent ?? null,
     createdAt: now2
   });
   if (isEmbeddingAvailable()) {
@@ -78101,6 +78131,116 @@ var init_claude_mem_migration = __esm({
   }
 });
 
+// packages/core/src/memory/mental-model-queue.ts
+async function drainQueue() {
+  if (_queue.length === 0) return 0;
+  const batch = _queue.splice(0, _queue.length);
+  let count4 = 0;
+  const { observeBrain: observeBrain2 } = await Promise.resolve().then(() => (init_brain_retrieval(), brain_retrieval_exports));
+  for (const entry of batch) {
+    try {
+      const result = await observeBrain2(entry.projectRoot, entry.params);
+      entry.resolve(result);
+      count4++;
+    } catch (err) {
+      const error48 = err instanceof Error ? err : new Error(String(err));
+      entry.reject(error48);
+    }
+  }
+  return count4;
+}
+function exitFlush() {
+  if (_queue.length === 0) return;
+  drainQueue().catch(() => {
+  });
+}
+function registerExitHooks() {
+  if (_hooksRegistered) return;
+  _hooksRegistered = true;
+  process.on("exit", exitFlush);
+  process.once("SIGINT", () => {
+    drainQueue().catch(() => {
+    }).finally(() => {
+      process.exit(130);
+    });
+  });
+  process.once("SIGTERM", () => {
+    drainQueue().catch(() => {
+    }).finally(() => {
+      process.exit(143);
+    });
+  });
+}
+function ensureTimer() {
+  if (_timer !== void 0) return;
+  _timer = setInterval(() => {
+    if (_queue.length === 0) return;
+    if (_flushing) return;
+    _flushing = true;
+    drainQueue().catch(() => {
+    }).finally(() => {
+      _flushing = false;
+    });
+  }, FLUSH_INTERVAL_MS);
+  if (typeof _timer.unref === "function") {
+    _timer.unref();
+  }
+}
+function isMentalModelObservation(params) {
+  if (!params.agent) return false;
+  const type = params.type ?? "discovery";
+  return MENTAL_MODEL_TYPES.has(type);
+}
+var FLUSH_INTERVAL_MS, FLUSH_WATERMARK, MENTAL_MODEL_TYPES, _queue, _flushing, _hooksRegistered, _timer, mentalModelQueue;
+var init_mental_model_queue = __esm({
+  "packages/core/src/memory/mental-model-queue.ts"() {
+    "use strict";
+    FLUSH_INTERVAL_MS = 5e3;
+    FLUSH_WATERMARK = 50;
+    MENTAL_MODEL_TYPES = /* @__PURE__ */ new Set([
+      "discovery",
+      "change",
+      "feature",
+      "decision",
+      "bugfix",
+      "refactor"
+    ]);
+    _queue = [];
+    _flushing = false;
+    _hooksRegistered = false;
+    mentalModelQueue = {
+      enqueue(projectRoot, params) {
+        registerExitHooks();
+        ensureTimer();
+        return new Promise((resolve16, reject) => {
+          _queue.push({ projectRoot, params, resolve: resolve16, reject });
+          if (_queue.length >= FLUSH_WATERMARK && !_flushing) {
+            _flushing = true;
+            drainQueue().catch(() => {
+            }).finally(() => {
+              _flushing = false;
+            });
+          }
+        });
+      },
+      async flush() {
+        if (_flushing) {
+          await new Promise((r) => setTimeout(r, 50));
+        }
+        _flushing = true;
+        try {
+          return await drainQueue();
+        } finally {
+          _flushing = false;
+        }
+      },
+      size() {
+        return _queue.length;
+      }
+    };
+  }
+});
+
 // packages/core/src/memory/brain-reasoning.ts
 var brain_reasoning_exports = {};
 __export(brain_reasoning_exports, {
@@ -78476,7 +78616,8 @@ async function memoryFind(params, projectRoot) {
       limit: params.limit,
       tables: params.tables,
       dateStart: params.dateStart,
-      dateEnd: params.dateEnd
+      dateEnd: params.dateEnd,
+      agent: params.agent
     });
     return { success: true, data: result };
   } catch (error48) {
@@ -78526,14 +78667,24 @@ async function memoryFetch(params, projectRoot) {
 async function memoryObserve(params, projectRoot) {
   try {
     const root = resolveRoot(projectRoot);
-    const result = await observeBrain(root, {
+    const observeParams = {
       text: params.text,
       title: params.title,
       type: params.type,
       project: params.project,
       sourceSessionId: params.sourceSessionId,
-      sourceType: params.sourceType
-    });
+      sourceType: params.sourceType,
+      agent: params.agent
+    };
+    let result;
+    if (isMentalModelObservation(observeParams) && observeParams.agent) {
+      result = await mentalModelQueue.enqueue(root, {
+        ...observeParams,
+        agent: observeParams.agent
+      });
+    } else {
+      result = await observeBrain(root, observeParams);
+    }
     return { success: true, data: result };
   } catch (error48) {
     return {
@@ -79133,6 +79284,7 @@ var init_engine_compat = __esm({
     init_brain_links();
     init_brain_retrieval();
     init_learnings();
+    init_mental_model_queue();
     init_patterns();
   }
 });
@@ -101465,11 +101617,31 @@ var init_registry5 = __esm({
         gateway: "query",
         domain: "orchestrate",
         operation: "analyze",
-        description: "orchestrate.analyze (query) \u2014 absorbs critical.path via mode param",
+        description: 'orchestrate.analyze (query) \u2014 absorbs critical.path via mode param; Wave 7a adds mode="parallel-safety"',
         tier: 1,
         idempotent: true,
         sessionRequired: false,
-        requiredParams: []
+        requiredParams: [],
+        params: [
+          {
+            name: "epicId",
+            type: "string",
+            required: false,
+            description: "Epic ID for standard analysis (required unless mode=critical-path or parallel-safety)"
+          },
+          {
+            name: "mode",
+            type: "string",
+            required: false,
+            description: 'Analysis mode: omit for standard analysis, "critical-path" for CPM, "parallel-safety" for dep-graph grouping'
+          },
+          {
+            name: "taskIds",
+            type: "array",
+            required: false,
+            description: 'Task ID list for mode="parallel-safety" \u2014 returns {parallelSafe, groups} dep-graph analysis'
+          }
+        ]
       },
       {
         gateway: "query",
@@ -101524,7 +101696,16 @@ var init_registry5 = __esm({
         tier: 0,
         idempotent: true,
         sessionRequired: false,
-        requiredParams: ["query"]
+        requiredParams: ["query"],
+        params: [
+          {
+            name: "agent",
+            type: "string",
+            required: false,
+            description: "Filter results to observations produced by the named agent (T418 mental models)",
+            cli: { flag: "--agent <name>" }
+          }
+        ]
       },
       {
         gateway: "query",
@@ -104053,6 +104234,70 @@ var init_registry5 = __esm({
         sessionRequired: false,
         requiredParams: ["templateId", "epicId"]
       },
+      // orchestrate — Wave 7a dispatch ops (T408, T409, T410, T415)
+      {
+        gateway: "query",
+        domain: "orchestrate",
+        operation: "classify",
+        description: "orchestrate.classify (query) \u2014 classify a request against CANT team registry to route to correct team/lead/protocol",
+        tier: 2,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: ["request"],
+        params: [
+          {
+            name: "request",
+            type: "string",
+            required: true,
+            description: "The request or task description to classify against team consult-when hints"
+          },
+          {
+            name: "context",
+            type: "string",
+            required: false,
+            description: "Optional additional context to improve classification accuracy"
+          }
+        ]
+      },
+      {
+        gateway: "query",
+        domain: "orchestrate",
+        operation: "fanout.status",
+        description: "orchestrate.fanout.status (query) \u2014 get status of a running fanout by its manifest entry ID",
+        tier: 2,
+        idempotent: true,
+        sessionRequired: false,
+        requiredParams: ["manifestEntryId"],
+        params: [
+          {
+            name: "manifestEntryId",
+            type: "string",
+            required: true,
+            description: "Manifest entry ID returned by orchestrate.fanout"
+          }
+        ]
+      },
+      {
+        gateway: "mutate",
+        domain: "orchestrate",
+        operation: "fanout",
+        description: "orchestrate.fanout (mutate) \u2014 fan out N spawn requests in parallel via Promise.allSettled",
+        tier: 2,
+        idempotent: false,
+        sessionRequired: false,
+        requiredParams: ["items"],
+        params: [
+          {
+            name: "items",
+            type: "array",
+            required: true,
+            description: "Array of {team, taskId, skill?} objects to fan out"
+          }
+        ]
+      },
+      // orchestrate — Wave 7a: analyze parallel-safety mode (T410)
+      // Note: orchestrate.analyze already registered above; this documents the new
+      // mode="parallel-safety" variant via the existing analyze operation's params.
       // conduit — agent messaging operations (replaces standalone clawmsgr scripts)
       {
         gateway: "query",
@@ -105631,13 +105876,27 @@ async function orchestrateSpawnExecute(taskId, adapterId, protocolType, projectR
         }
       };
     }
+    let composedPrompt = spawnContext.prompt;
+    try {
+      const { composeSpawnPayload } = await import("@cleocode/cant");
+      const { brainContextProvider } = await import("@cleocode/cant");
+      const { createHash: createHash14 } = await import("node:crypto");
+      const projectHash = createHash14("sha256").update(cwd).digest("hex").slice(0, 12);
+      const agentDef = spawnContext.agentDef;
+      if (agentDef) {
+        const provider2 = brainContextProvider(cwd);
+        const payload = await composeSpawnPayload(agentDef, provider2, projectHash);
+        composedPrompt = payload.systemPrompt;
+      }
+    } catch {
+    }
     const cleoSpawnContext = {
       taskId: spawnContext.taskId,
       protocol: protocolType || spawnContext.protocol,
-      prompt: spawnContext.prompt,
+      prompt: composedPrompt,
       provider: provider.id,
       options: {
-        prompt: spawnContext.prompt
+        prompt: composedPrompt
       },
       workingDirectory: cwd,
       tokenResolution: {
@@ -110231,7 +110490,9 @@ var init_memory2 = __esm({
                   limit: params?.limit,
                   tables: params?.tables,
                   dateStart: params?.dateStart,
-                  dateEnd: params?.dateEnd
+                  dateEnd: params?.dateEnd,
+                  // T418: optional agent filter for per-agent mental model retrieval
+                  agent: params?.agent
                 },
                 projectRoot
               );
@@ -110440,7 +110701,9 @@ var init_memory2 = __esm({
                   type: params?.type,
                   project: params?.project,
                   sourceSessionId: params?.sourceSessionId,
-                  sourceType: params?.sourceType
+                  sourceType: params?.sourceType,
+                  // T417: optional agent provenance for mental model observations
+                  agent: params?.agent
                 },
                 projectRoot
               );
@@ -111241,7 +111504,241 @@ var init_nexus2 = __esm({
 });
 
 // packages/cleo/src/dispatch/domains/orchestrate.ts
-var OrchestrateHandler;
+async function orchestrateClassify(request, context, projectRoot) {
+  try {
+    const { getCleoCantWorkflowsDir: getCleoCantWorkflowsDir2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+    const { readFileSync: readFileSync101, readdirSync: readdirSync42, existsSync: existsSync131 } = await import("node:fs");
+    const { join: join131 } = await import("node:path");
+    const workflowsDir = getCleoCantWorkflowsDir2();
+    const combined = `${request} ${context ?? ""}`.toLowerCase();
+    const matches = [];
+    if (existsSync131(workflowsDir)) {
+      const files = readdirSync42(workflowsDir).filter((f2) => f2.endsWith(".cant"));
+      for (const file2 of files) {
+        try {
+          const src = readFileSync101(join131(workflowsDir, file2), "utf-8");
+          const teamMatch = /^team\s+(\S+):/m.exec(src);
+          if (!teamMatch) continue;
+          const teamName = teamMatch[1];
+          const cwMatch = /consult-when:\s*["']?(.+?)["']?\s*$/m.exec(src);
+          const consultWhen = cwMatch ? cwMatch[1].trim() : "";
+          const stagesMatch = /stages:\s*\[([^\]]+)\]/.exec(src);
+          const stages = stagesMatch ? stagesMatch[1].split(",").map((s3) => s3.trim()) : [];
+          const hintWords = consultWhen.toLowerCase().split(/\s+/);
+          const score = hintWords.filter((w2) => combined.includes(w2)).length;
+          matches.push({ team: teamName, score, consultWhen, stages });
+        } catch {
+        }
+      }
+    }
+    const localCantDir = join131(projectRoot, ".cleo", "workflows");
+    if (existsSync131(localCantDir)) {
+      const files = readdirSync42(localCantDir).filter((f2) => f2.endsWith(".cant"));
+      for (const file2 of files) {
+        try {
+          const src = readFileSync101(join131(localCantDir, file2), "utf-8");
+          const teamMatch = /^team\s+(\S+):/m.exec(src);
+          if (!teamMatch) continue;
+          const teamName = teamMatch[1];
+          const cwMatch = /consult-when:\s*["']?(.+?)["']?\s*$/m.exec(src);
+          const consultWhen = cwMatch ? cwMatch[1].trim() : "";
+          const stagesMatch = /stages:\s*\[([^\]]+)\]/.exec(src);
+          const stages = stagesMatch ? stagesMatch[1].split(",").map((s3) => s3.trim()) : [];
+          const hintWords = consultWhen.toLowerCase().split(/\s+/);
+          const score = hintWords.filter((w2) => combined.includes(w2)).length;
+          matches.push({ team: teamName, score, consultWhen, stages });
+        } catch {
+        }
+      }
+    }
+    if (matches.length === 0) {
+      return {
+        success: true,
+        data: {
+          team: null,
+          lead: null,
+          protocol: null,
+          stage: null,
+          confidence: 0,
+          reasoning: "No CANT team definitions found. Seed teams.cant in the global workflows dir (W7b runtime enforcement) to enable team routing."
+        }
+      };
+    }
+    matches.sort((a, b2) => b2.score - a.score);
+    const best = matches[0];
+    return {
+      success: true,
+      data: {
+        team: best.team,
+        lead: null,
+        // lead resolution requires W7b runtime bridge
+        protocol: "base-subagent",
+        // default protocol stub
+        stage: best.stages[0] ?? null,
+        confidence: best.score > 0 ? 0.5 : 0.1,
+        reasoning: best.score > 0 ? `Matched team '${best.team}' via consult-when hint: "${best.consultWhen}"` : `No strong match found; defaulting to first registered team '${best.team}'`
+      }
+    };
+  } catch (error48) {
+    getLogger("domain:orchestrate").error(
+      { operation: "classify", err: error48 },
+      error48 instanceof Error ? error48.message : String(error48)
+    );
+    return {
+      success: false,
+      error: {
+        code: "E_CLASSIFY_FAILED",
+        message: error48 instanceof Error ? error48.message : String(error48)
+      }
+    };
+  }
+}
+async function orchestrateFanout(items, projectRoot) {
+  const manifestEntryId = `fanout-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    const settled = await Promise.allSettled(
+      items.map(async (item) => {
+        const spawnResult = await orchestrateSpawnExecute(
+          item.taskId,
+          /* adapterId */
+          void 0,
+          /* protocolType */
+          void 0,
+          projectRoot,
+          /* tier */
+          void 0
+        );
+        if (!spawnResult.success) {
+          return {
+            taskId: item.taskId,
+            status: "failed",
+            error: spawnResult.error?.message ?? `Spawn failed for task ${item.taskId}`
+          };
+        }
+        const data = spawnResult.data;
+        return {
+          taskId: item.taskId,
+          status: "spawned",
+          instanceId: typeof data?.instanceId === "string" ? data.instanceId : void 0
+        };
+      })
+    );
+    const results = settled.map((outcome, i) => {
+      if (outcome.status === "fulfilled") {
+        return outcome.value;
+      }
+      return {
+        taskId: items[i].taskId,
+        status: "failed",
+        error: outcome.reason instanceof Error ? outcome.reason.message : String(outcome.reason)
+      };
+    });
+    fanoutManifestStore.set(manifestEntryId, {
+      results,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return {
+      success: true,
+      data: {
+        manifestEntryId,
+        results,
+        total: items.length,
+        spawned: results.filter((r) => r.status === "spawned").length,
+        failed: results.filter((r) => r.status === "failed").length
+      }
+    };
+  } catch (error48) {
+    getLogger("domain:orchestrate").error(
+      { operation: "fanout", err: error48 },
+      error48 instanceof Error ? error48.message : String(error48)
+    );
+    return {
+      success: false,
+      error: {
+        code: "E_FANOUT_FAILED",
+        message: error48 instanceof Error ? error48.message : String(error48)
+      }
+    };
+  }
+}
+async function orchestrateAnalyzeParallelSafety(taskIds, projectRoot) {
+  if (taskIds.length === 0) {
+    return {
+      success: true,
+      data: {
+        parallelSafe: true,
+        groups: [],
+        note: "No tasks provided \u2014 trivially parallel-safe"
+      }
+    };
+  }
+  try {
+    let transitiveClose2 = function(id, visited = /* @__PURE__ */ new Set()) {
+      if (visited.has(id)) return visited;
+      visited.add(id);
+      const deps = depMap.get(id) ?? [];
+      for (const dep of deps) {
+        transitiveClose2(dep, visited);
+      }
+      return visited;
+    }, parallelSafe2 = function(a, b2) {
+      const closureA = closures.get(a) ?? /* @__PURE__ */ new Set();
+      const closureB = closures.get(b2) ?? /* @__PURE__ */ new Set();
+      return !closureA.has(b2) && !closureB.has(a);
+    };
+    var transitiveClose = transitiveClose2, parallelSafe = parallelSafe2;
+    const { getAccessor: getAccessor2 } = await Promise.resolve().then(() => (init_internal(), internal_exports));
+    const accessor = await getAccessor2(projectRoot);
+    const result = await accessor.queryTasks({});
+    const allTasks = result?.tasks ?? [];
+    const depMap = /* @__PURE__ */ new Map();
+    for (const t of allTasks) {
+      const deps = t.blockers ?? [];
+      depMap.set(t.id, deps);
+    }
+    const closures = /* @__PURE__ */ new Map();
+    for (const id of taskIds) {
+      closures.set(id, transitiveClose2(id));
+    }
+    const groups = [];
+    for (const id of taskIds) {
+      let placed = false;
+      for (const group of groups) {
+        if (group.every((member) => parallelSafe2(id, member))) {
+          group.push(id);
+          placed = true;
+          break;
+        }
+      }
+      if (!placed) {
+        groups.push([id]);
+      }
+    }
+    const isFullyParallelSafe = groups.length <= 1;
+    return {
+      success: true,
+      data: {
+        parallelSafe: isFullyParallelSafe,
+        groups,
+        taskCount: taskIds.length,
+        groupCount: groups.length
+      }
+    };
+  } catch (error48) {
+    getLogger("domain:orchestrate").error(
+      { operation: "analyze/parallel-safety", err: error48 },
+      error48 instanceof Error ? error48.message : String(error48)
+    );
+    return {
+      success: false,
+      error: {
+        code: "E_ANALYZE_FAILED",
+        message: error48 instanceof Error ? error48.message : String(error48)
+      }
+    };
+  }
+}
+var OrchestrateHandler, fanoutManifestStore;
 var init_orchestrate2 = __esm({
   "packages/cleo/src/dispatch/domains/orchestrate.ts"() {
     "use strict";
@@ -111297,9 +111794,73 @@ var init_orchestrate2 = __esm({
             case "analyze": {
               const epicId = params?.epicId;
               const mode = params?.mode;
+              if (mode === "parallel-safety") {
+                const taskIds = params?.taskIds;
+                const result2 = await orchestrateAnalyzeParallelSafety(taskIds ?? [], projectRoot);
+                return wrapResult(result2, "query", "orchestrate", "analyze", startTime);
+              }
               const result = await orchestrateAnalyze(epicId, projectRoot, mode);
               return wrapResult(result, "query", "orchestrate", "analyze", startTime);
             }
+            case "classify": {
+              const request = params?.request;
+              if (!request) {
+                return errorResult(
+                  "query",
+                  "orchestrate",
+                  operation,
+                  "E_INVALID_INPUT",
+                  "request is required",
+                  startTime
+                );
+              }
+              const context = params?.context;
+              const result = await orchestrateClassify(request, context, projectRoot);
+              return wrapResult(result, "query", "orchestrate", operation, startTime);
+            }
+            case "fanout.status": {
+              const manifestEntryId = params?.manifestEntryId;
+              if (!manifestEntryId) {
+                return errorResult(
+                  "query",
+                  "orchestrate",
+                  operation,
+                  "E_INVALID_INPUT",
+                  "manifestEntryId is required",
+                  startTime
+                );
+              }
+              const entry = fanoutManifestStore.get(manifestEntryId);
+              if (!entry) {
+                return {
+                  meta: dispatchMeta("query", "orchestrate", operation, startTime),
+                  success: true,
+                  data: {
+                    manifestEntryId,
+                    pending: [],
+                    running: [],
+                    complete: [],
+                    failed: [],
+                    found: false
+                  }
+                };
+              }
+              const spawned = entry.results.filter((r) => r.status === "spawned").map((r) => r.taskId);
+              const failed = entry.results.filter((r) => r.status === "failed").map((r) => r.taskId);
+              return {
+                meta: dispatchMeta("query", "orchestrate", operation, startTime),
+                success: true,
+                data: {
+                  manifestEntryId,
+                  pending: [],
+                  running: spawned,
+                  complete: [],
+                  failed,
+                  found: true,
+                  completedAt: entry.completedAt
+                }
+              };
+            }
             case "context": {
               const epicId = params?.epicId;
               const result = await orchestrateContext(epicId, projectRoot);
@@ -111552,6 +112113,21 @@ var init_orchestrate2 = __esm({
                 }
               });
             }
+            case "fanout": {
+              const items = params?.items;
+              if (!items || !Array.isArray(items) || items.length === 0) {
+                return errorResult(
+                  "mutate",
+                  "orchestrate",
+                  operation,
+                  "E_INVALID_INPUT",
+                  "items array is required and must be non-empty",
+                  startTime
+                );
+              }
+              const result = await orchestrateFanout(items, projectRoot);
+              return wrapResult(result, "mutate", "orchestrate", operation, startTime);
+            }
             case "tessera.instantiate": {
               const templateId = params?.templateId;
               const epicId = params?.epicId;
@@ -111627,7 +112203,10 @@ var init_orchestrate2 = __esm({
             "waves",
             "bootstrap",
             "unblock.opportunities",
-            "tessera.list"
+            "tessera.list",
+            // Wave 7a (T379)
+            "classify",
+            "fanout.status"
           ],
           mutate: [
             "start",
@@ -111636,11 +112215,14 @@ var init_orchestrate2 = __esm({
             "spawn.execute",
             "validate",
             "parallel",
-            "tessera.instantiate"
+            "tessera.instantiate",
+            // Wave 7a (T379)
+            "fanout"
           ]
         };
       }
     };
+    fanoutManifestStore = /* @__PURE__ */ new Map();
   }
 });
 
@@ -121160,7 +121742,7 @@ function registerMemoryBrainCommand(program) {
   memory.command("find <query>").description("Search BRAIN memory (all tables, or filter by --type pattern|learning)").option("--type <type>", "Filter by memory type: pattern or learning (default: all)").option(
     "--pattern-type <type>",
     "Filter patterns by type: workflow, blocker, success, failure, optimization"
-  ).option("--min-confidence <n>", "Minimum confidence for learnings", parseFloat).option("--actionable", "Only show actionable learnings").option("--limit <n>", "Maximum results", parseInt).option("--json", "Output as JSON").action(async (query, opts) => {
+  ).option("--min-confidence <n>", "Minimum confidence for learnings", parseFloat).option("--actionable", "Only show actionable learnings").option("--limit <n>", "Maximum results", parseInt).option("--agent <name>", "Filter observations by agent provenance name (Wave 8 mental models)").option("--json", "Output as JSON").action(async (query, opts) => {
     const memType = opts["type"];
     if (memType === "pattern") {
       await dispatchFromCli(
@@ -121194,7 +121776,9 @@ function registerMemoryBrainCommand(program) {
         "find",
         {
           query,
-          limit: opts["limit"]
+          limit: opts["limit"],
+          // T418: forward agent filter when provided
+          ...opts["agent"] !== void 0 && { agent: opts["agent"] }
         },
         { command: "memory", operation: "memory.find" }
       );
@@ -121218,14 +121802,18 @@ function registerMemoryBrainCommand(program) {
     }
     cliOutput(result, { command: "memory", operation: "memory.stats" });
   });
-  memory.command("observe <text>").description("Save an observation to brain.db").option("--title <title>", "Short title for the observation").action(async (text3, opts) => {
+  memory.command("observe <text>").description("Save an observation to brain.db").option("--title <title>", "Short title for the observation").option(
+    "--agent <name>",
+    "Tag this observation with the producing agent name (Wave 8 mental models)"
+  ).action(async (text3, opts) => {
     await dispatchFromCli(
       "mutate",
       "memory",
       "observe",
       {
         text: text3,
-        title: opts["title"]
+        title: opts["title"],
+        ...opts["agent"] !== void 0 && { agent: opts["agent"] }
       },
       { command: "memory", operation: "memory.observe" }
     );