@cleocode/core 2026.3.73 → 2026.3.74

package/dist/index.js

@@ -631,6 +631,13 @@ var init_discovery = __esm({
 });
 
 // packages/core/src/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  closeLogger: () => closeLogger,
+  getLogDir: () => getLogDir,
+  getLogger: () => getLogger,
+  initLogger: () => initLogger
+});
 import { existsSync as existsSync2 } from "node:fs";
 import { dirname, join as join3 } from "node:path";
 import pino from "pino";
@@ -21512,6 +21519,54 @@ var init_codebase_map = __esm({
   }
 });
 
+// packages/core/src/tasks/dependency-check.ts
+function getUnresolvedDeps(taskId, tasks2) {
+  const task = tasks2.find((t) => t.id === taskId);
+  if (!task?.depends?.length) return [];
+  const completedIds = new Set(
+    tasks2.filter((t) => t.status === "done" || t.status === "cancelled").map((t) => t.id)
+  );
+  return task.depends.filter((depId) => !completedIds.has(depId));
+}
+function topologicalSort2(tasks2) {
+  const inDegree = /* @__PURE__ */ new Map();
+  const adjList = /* @__PURE__ */ new Map();
+  for (const task of tasks2) {
+    inDegree.set(task.id, 0);
+    adjList.set(task.id, []);
+  }
+  for (const task of tasks2) {
+    if (!task.depends?.length) continue;
+    for (const depId of task.depends) {
+      if (adjList.has(depId)) {
+        adjList.get(depId).push(task.id);
+        inDegree.set(task.id, (inDegree.get(task.id) ?? 0) + 1);
+      }
+    }
+  }
+  const queue = [];
+  for (const [id, degree] of inDegree) {
+    if (degree === 0) queue.push(id);
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const id = queue.shift();
+    sorted.push(id);
+    for (const dependent of adjList.get(id) ?? []) {
+      const newDegree = (inDegree.get(dependent) ?? 1) - 1;
+      inDegree.set(dependent, newDegree);
+      if (newDegree === 0) queue.push(dependent);
+    }
+  }
+  if (sorted.length !== tasks2.length) return null;
+  return sorted;
+}
+var init_dependency_check = __esm({
+  "packages/core/src/tasks/dependency-check.ts"() {
+    "use strict";
+  }
+});
+
 // packages/core/src/tasks/hierarchy.ts
 function getParentChain(taskId, tasks2) {
   const chain = [];
@@ -24958,7 +25013,150 @@ var init_registry3 = __esm({
   }
 });
 
+// packages/core/src/task-work/index.ts
+var task_work_exports = {};
+__export(task_work_exports, {
+  currentTask: () => currentTask,
+  getTaskHistory: () => getTaskHistory,
+  getWorkHistory: () => getWorkHistory,
+  startTask: () => startTask,
+  stopTask: () => stopTask
+});
+async function currentTask(cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const focus = await acc.getMetaValue("focus_state");
+  return {
+    currentTask: focus?.currentTask ?? null,
+    currentPhase: focus?.currentPhase ?? null,
+    sessionNote: focus?.sessionNote ?? null,
+    nextAction: focus?.nextAction ?? null
+  };
+}
+async function startTask(taskId, cwd, accessor) {
+  if (!taskId) {
+    throw new CleoError(2 /* INVALID_INPUT */, "Task ID is required");
+  }
+  const acc = accessor ?? await getAccessor(cwd);
+  const task = await acc.loadSingleTask(taskId);
+  if (!task) {
+    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${taskId}`, {
+      fix: `Use 'cleo find "${taskId}"' to search`
+    });
+  }
+  const { tasks: allTasks } = await acc.queryTasks({});
+  const unresolvedDeps = getUnresolvedDeps(taskId, allTasks);
+  if (unresolvedDeps.length > 0) {
+    throw new CleoError(
+      5 /* DEPENDENCY_ERROR */,
+      `Task ${taskId} is blocked by unresolved dependencies: ${unresolvedDeps.join(", ")}`,
+      {
+        fix: `Complete blockers first: ${unresolvedDeps.map((d) => `cleo complete ${d}`).join(", ")}`
+      }
+    );
+  }
+  const focus = await acc.getMetaValue("focus_state") ?? {};
+  const previousTask = focus.currentTask ?? null;
+  focus.currentTask = taskId;
+  focus.currentPhase = task.phase ?? null;
+  const noteEntry = {
+    note: `Started work on ${taskId}: ${task.title}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  if (!focus.sessionNotes) {
+    focus.sessionNotes = [];
+  }
+  focus.sessionNotes.push(noteEntry);
+  await acc.setMetaValue("focus_state", focus);
+  await logOperation(
+    "task_start",
+    taskId,
+    {
+      previousTask,
+      title: task.title
+    },
+    accessor
+  );
+  const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+  hooks2.dispatch("PreToolUse", cwd ?? process.cwd(), {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    taskId,
+    taskTitle: task.title
+  }).catch(() => {
+  });
+  return {
+    taskId,
+    taskTitle: task.title,
+    previousTask
+  };
+}
+async function stopTask(cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const focus = await acc.getMetaValue("focus_state");
+  const previousTask = focus?.currentTask ?? null;
+  if (!focus) {
+    return { previousTask: null };
+  }
+  const taskId = focus.currentTask;
+  const task = taskId ? await acc.loadSingleTask(taskId) : void 0;
+  focus.currentTask = null;
+  focus.nextAction = null;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  if (taskId && task) {
+    const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
+    hooks2.dispatch("PostToolUse", cwd ?? process.cwd(), {
+      timestamp: now,
+      taskId,
+      taskTitle: task.title,
+      status: "done"
+    }).catch(() => {
+    });
+  }
+  await acc.setMetaValue("focus_state", focus);
+  await logOperation(
+    "task_stop",
+    previousTask ?? "none",
+    {
+      previousTask
+    },
+    accessor
+  );
+  return { previousTask };
+}
+async function getWorkHistory(cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const focus = await acc.getMetaValue("focus_state");
+  const notes = focus?.sessionNotes ?? [];
+  const history = [];
+  for (const note of notes) {
+    const match = note.note.match(/^(?:Focus set to|Started work on) (T\d+)/);
+    if (match) {
+      history.push({
+        taskId: match[1],
+        timestamp: note.timestamp
+      });
+    }
+  }
+  return history.reverse();
+}
+var getTaskHistory;
+var init_task_work = __esm({
+  "packages/core/src/task-work/index.ts"() {
+    "use strict";
+    init_src();
+    init_errors3();
+    init_data_accessor();
+    init_add();
+    init_dependency_check();
+    init_handlers();
+    getTaskHistory = getWorkHistory;
+  }
+});
+
 // packages/core/src/tasks/complete.ts
+var complete_exports = {};
+__export(complete_exports, {
+  completeTask: () => completeTask
+});
 function isVerificationGate(value) {
   return VERIFICATION_GATES.has(value);
 }
@@ -40866,50 +41064,8 @@ async function maybeExtractLearning(taskId, task, verification, confidenceScore,
 // packages/core/src/intelligence/impact.ts
 init_data_accessor();
 
-// packages/core/src/tasks/dependency-check.ts
-function getUnresolvedDeps(taskId, tasks2) {
-  const task = tasks2.find((t) => t.id === taskId);
-  if (!task?.depends?.length) return [];
-  const completedIds = new Set(
-    tasks2.filter((t) => t.status === "done" || t.status === "cancelled").map((t) => t.id)
-  );
-  return task.depends.filter((depId) => !completedIds.has(depId));
-}
-function topologicalSort2(tasks2) {
-  const inDegree = /* @__PURE__ */ new Map();
-  const adjList = /* @__PURE__ */ new Map();
-  for (const task of tasks2) {
-    inDegree.set(task.id, 0);
-    adjList.set(task.id, []);
-  }
-  for (const task of tasks2) {
-    if (!task.depends?.length) continue;
-    for (const depId of task.depends) {
-      if (adjList.has(depId)) {
-        adjList.get(depId).push(task.id);
-        inDegree.set(task.id, (inDegree.get(task.id) ?? 0) + 1);
-      }
-    }
-  }
-  const queue = [];
-  for (const [id, degree] of inDegree) {
-    if (degree === 0) queue.push(id);
-  }
-  const sorted = [];
-  while (queue.length > 0) {
-    const id = queue.shift();
-    sorted.push(id);
-    for (const dependent of adjList.get(id) ?? []) {
-      const newDegree = (inDegree.get(dependent) ?? 1) - 1;
-      inDegree.set(dependent, newDegree);
-      if (newDegree === 0) queue.push(dependent);
-    }
-  }
-  if (sorted.length !== tasks2.length) return null;
-  return sorted;
-}
-
 // packages/core/src/tasks/graph-ops.ts
+init_dependency_check();
 function getCriticalPath(tasks2) {
   const activeTasks = tasks2.filter((t) => t.status !== "done" && t.status !== "cancelled");
   if (activeTasks.length === 0) return [];
@@ -46786,6 +46942,7 @@ __export(nexus_exports, {
   nexusSyncAll: () => nexusSyncAll,
   nexusUnregister: () => nexusUnregister,
   orphanDetection: () => orphanDetection,
+  parseDirective: () => parseDirective,
   parseQuery: () => parseQuery,
   permissionLevel: () => permissionLevel,
   previewTransfer: () => previewTransfer,
@@ -46796,10 +46953,13 @@ __export(nexus_exports, {
   resolveCrossDeps: () => resolveCrossDeps,
   resolveProjectPath: () => resolveProjectPath2,
   resolveTask: () => resolveTask,
+  routeDirective: () => routeDirective,
   searchAcrossProjects: () => searchAcrossProjects,
   setPermission: () => setPermission,
   syncGitignore: () => syncGitignore,
-  validateSyntax: () => validateSyntax
+  validateSyntax: () => validateSyntax,
+  workspaceAgents: () => workspaceAgents,
+  workspaceStatus: () => workspaceStatus
 });
 
 // packages/core/src/nexus/deps.ts
@@ -48025,6 +48185,275 @@ async function executeTransferInternal(params) {
   return result;
 }
 
+// packages/core/src/nexus/workspace.ts
+init_src();
+init_errors3();
+init_data_accessor();
+init_registry3();
+var RATE_LIMIT_WINDOW_MS = 6e4;
+var RATE_LIMIT_MAX_OPS = 100;
+var rateLimitCounters = /* @__PURE__ */ new Map();
+function checkRateLimit(agentId) {
+  const now = Date.now();
+  const entry = rateLimitCounters.get(agentId);
+  if (!entry || now - entry.windowStart > RATE_LIMIT_WINDOW_MS) {
+    rateLimitCounters.set(agentId, { count: 1, windowStart: now });
+    return;
+  }
+  entry.count++;
+  if (entry.count > RATE_LIMIT_MAX_OPS) {
+    throw new CleoError(
+      1 /* GENERAL_ERROR */,
+      `Agent '${agentId}' exceeded rate limit: ${RATE_LIMIT_MAX_OPS} routing ops per ${RATE_LIMIT_WINDOW_MS / 1e3}s`
+    );
+  }
+}
+var DEFAULT_ACL = { authorizedAgents: ["*"] };
+async function loadProjectACL(projectPath) {
+  try {
+    const { loadConfig: loadConfig3 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig3(projectPath);
+    const agents = config2?.authorizedAgents;
+    if (Array.isArray(agents) && agents.length > 0) {
+      return { authorizedAgents: agents };
+    }
+  } catch {
+  }
+  return DEFAULT_ACL;
+}
+function isAuthorized(acl, agentId) {
+  if (acl.authorizedAgents.includes("*")) return true;
+  return acl.authorizedAgents.includes(agentId);
+}
+var TASK_REF_PATTERN = /\bT(\d+)\b/g;
+function parseDirective(message) {
+  const content = message.content;
+  const verbMatch = content.match(/^\/(\w+)/);
+  if (!verbMatch) return null;
+  const verb = verbMatch[1];
+  const taskRefs = [];
+  const pattern = new RegExp(TASK_REF_PATTERN.source, "g");
+  for (const m of content.matchAll(pattern)) {
+    taskRefs.push(`T${m[1]}`);
+  }
+  const metaRefs = message.metadata?.taskRefs;
+  if (Array.isArray(metaRefs)) {
+    for (const ref of metaRefs) {
+      if (typeof ref === "string" && !taskRefs.includes(ref)) {
+        taskRefs.push(ref);
+      }
+    }
+  }
+  if (taskRefs.length === 0) return null;
+  return {
+    verb,
+    taskRefs,
+    agentId: message.from,
+    messageId: message.id,
+    timestamp: message.timestamp
+  };
+}
+var VERB_TO_OPERATION = {
+  claim: "tasks.start",
+  done: "tasks.complete",
+  complete: "tasks.complete",
+  blocked: "tasks.update",
+  // Update status to blocked
+  start: "tasks.start",
+  stop: "tasks.stop"
+};
+async function routeDirective(directive) {
+  checkRateLimit(directive.agentId);
+  const results = [];
+  const operation = VERB_TO_OPERATION[directive.verb];
+  if (!operation) {
+    return results;
+  }
+  const projects = await nexusList();
+  for (const taskRef of directive.taskRefs) {
+    const result = await routeSingleTask(taskRef, directive, operation, projects);
+    results.push(result);
+  }
+  return results;
+}
+async function routeSingleTask(taskId, directive, operation, projects) {
+  let targetProject = null;
+  let targetAccessor = null;
+  for (const project of projects) {
+    try {
+      const acc = await getAccessor(project.path);
+      const { tasks: tasks2 } = await acc.queryTasks({});
+      const task = tasks2.find((t) => t.id === taskId);
+      if (task) {
+        targetProject = project;
+        targetAccessor = acc;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!targetProject || !targetAccessor) {
+    return {
+      success: false,
+      project: "unknown",
+      projectPath: "",
+      taskId,
+      operation,
+      error: `Task ${taskId} not found in any registered project`
+    };
+  }
+  const acl = await loadProjectACL(targetProject.path);
+  if (!isAuthorized(acl, directive.agentId)) {
+    return {
+      success: false,
+      project: targetProject.name,
+      projectPath: targetProject.path,
+      taskId,
+      operation,
+      error: `Agent '${directive.agentId}' not authorized to mutate project '${targetProject.name}'`
+    };
+  }
+  try {
+    await executeOperation(operation, taskId, targetProject.path, targetAccessor, directive);
+    await logRouteAudit(directive, targetProject.name, taskId, operation, true);
+    return {
+      success: true,
+      project: targetProject.name,
+      projectPath: targetProject.path,
+      taskId,
+      operation
+    };
+  } catch (err) {
+    const errorMsg = err instanceof Error ? err.message : String(err);
+    await logRouteAudit(directive, targetProject.name, taskId, operation, false, errorMsg);
+    return {
+      success: false,
+      project: targetProject.name,
+      projectPath: targetProject.path,
+      taskId,
+      operation,
+      error: errorMsg
+    };
+  }
+}
+async function executeOperation(operation, taskId, projectPath, accessor, directive) {
+  switch (operation) {
+    case "tasks.start": {
+      const { startTask: startTask2 } = await Promise.resolve().then(() => (init_task_work(), task_work_exports));
+      await startTask2(taskId, projectPath, accessor);
+      break;
+    }
+    case "tasks.complete": {
+      const { completeTask: completeTask2 } = await Promise.resolve().then(() => (init_complete(), complete_exports));
+      await completeTask2(
+        { taskId, notes: `Completed via Conduit directive from ${directive.agentId}` },
+        projectPath,
+        accessor
+      );
+      break;
+    }
+    case "tasks.stop": {
+      const { stopTask: stopTask2 } = await Promise.resolve().then(() => (init_task_work(), task_work_exports));
+      await stopTask2(projectPath, accessor);
+      break;
+    }
+    case "tasks.update": {
+      const { updateTask: updateTask2 } = await Promise.resolve().then(() => (init_update2(), update_exports));
+      await updateTask2(
+        { taskId, notes: `Marked blocked via Conduit directive from ${directive.agentId}` },
+        projectPath,
+        accessor
+      );
+      break;
+    }
+  }
+}
+async function logRouteAudit(directive, projectName, taskId, operation, success2, error40) {
+  try {
+    const { getLogger: getLogger2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+    const log9 = getLogger2("nexus.route");
+    const level = success2 ? "info" : "warn";
+    log9[level](
+      {
+        directive: directive.verb,
+        agentId: directive.agentId,
+        messageId: directive.messageId,
+        project: projectName,
+        taskId,
+        operation,
+        success: success2,
+        error: error40
+      },
+      `Conduit directive routed: ${directive.verb} ${taskId} \u2192 ${projectName} (${success2 ? "OK" : "FAILED"})`
+    );
+  } catch {
+  }
+}
+async function workspaceStatus() {
+  const projects = await nexusList();
+  const summaries = [];
+  const totals = { pending: 0, active: 0, done: 0, total: 0 };
+  for (const project of projects) {
+    try {
+      const acc = await getAccessor(project.path);
+      const { tasks: tasks2 } = await acc.queryTasks({});
+      const counts = {
+        pending: tasks2.filter((t) => t.status === "pending").length,
+        active: tasks2.filter((t) => t.status === "active").length,
+        done: tasks2.filter((t) => t.status === "done").length,
+        total: tasks2.length
+      };
+      summaries.push({
+        name: project.name,
+        path: project.path,
+        counts,
+        health: project.healthStatus,
+        lastSync: project.lastSync
+      });
+      totals.pending += counts.pending;
+      totals.active += counts.active;
+      totals.done += counts.done;
+      totals.total += counts.total;
+    } catch {
+      summaries.push({
+        name: project.name,
+        path: project.path,
+        counts: { pending: 0, active: 0, done: 0, total: 0 },
+        health: "unreachable",
+        lastSync: project.lastSync
+      });
+    }
+  }
+  return {
+    projectCount: projects.length,
+    projects: summaries,
+    totals,
+    computedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function workspaceAgents() {
+  const projects = await nexusList();
+  const agents = [];
+  for (const project of projects) {
+    try {
+      const { listAgentInstances: listAgentInstances2 } = await Promise.resolve().then(() => (init_registry2(), registry_exports2));
+      const instances = await listAgentInstances2(void 0, project.path);
+      for (const inst of instances) {
+        agents.push({
+          agentId: inst.id,
+          agentType: inst.agentType,
+          status: inst.status,
+          project: project.name,
+          taskId: inst.taskId ?? null,
+          lastHeartbeat: inst.lastHeartbeat
+        });
+      }
+    } catch {
+    }
+  }
+  return agents;
+}
+
 // packages/core/src/observability/index.ts
 var observability_exports = {};
 __export(observability_exports, {
@@ -60827,137 +61256,8 @@ async function uncancelTask(projectRoot, params) {
   };
 }
 
-// packages/core/src/task-work/index.ts
-var task_work_exports = {};
-__export(task_work_exports, {
-  currentTask: () => currentTask,
-  getTaskHistory: () => getTaskHistory,
-  getWorkHistory: () => getWorkHistory,
-  startTask: () => startTask,
-  stopTask: () => stopTask
-});
-init_src();
-init_errors3();
-init_data_accessor();
-init_add();
-init_handlers();
-async function currentTask(cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const focus = await acc.getMetaValue("focus_state");
-  return {
-    currentTask: focus?.currentTask ?? null,
-    currentPhase: focus?.currentPhase ?? null,
-    sessionNote: focus?.sessionNote ?? null,
-    nextAction: focus?.nextAction ?? null
-  };
-}
-async function startTask(taskId, cwd, accessor) {
-  if (!taskId) {
-    throw new CleoError(2 /* INVALID_INPUT */, "Task ID is required");
-  }
-  const acc = accessor ?? await getAccessor(cwd);
-  const task = await acc.loadSingleTask(taskId);
-  if (!task) {
-    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${taskId}`, {
-      fix: `Use 'cleo find "${taskId}"' to search`
-    });
-  }
-  const { tasks: allTasks } = await acc.queryTasks({});
-  const unresolvedDeps = getUnresolvedDeps(taskId, allTasks);
-  if (unresolvedDeps.length > 0) {
-    throw new CleoError(
-      5 /* DEPENDENCY_ERROR */,
-      `Task ${taskId} is blocked by unresolved dependencies: ${unresolvedDeps.join(", ")}`,
-      {
-        fix: `Complete blockers first: ${unresolvedDeps.map((d) => `cleo complete ${d}`).join(", ")}`
-      }
-    );
-  }
-  const focus = await acc.getMetaValue("focus_state") ?? {};
-  const previousTask = focus.currentTask ?? null;
-  focus.currentTask = taskId;
-  focus.currentPhase = task.phase ?? null;
-  const noteEntry = {
-    note: `Started work on ${taskId}: ${task.title}`,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  if (!focus.sessionNotes) {
-    focus.sessionNotes = [];
-  }
-  focus.sessionNotes.push(noteEntry);
-  await acc.setMetaValue("focus_state", focus);
-  await logOperation(
-    "task_start",
-    taskId,
-    {
-      previousTask,
-      title: task.title
-    },
-    accessor
-  );
-  const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-  hooks2.dispatch("PreToolUse", cwd ?? process.cwd(), {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    taskId,
-    taskTitle: task.title
-  }).catch(() => {
-  });
-  return {
-    taskId,
-    taskTitle: task.title,
-    previousTask
-  };
-}
-async function stopTask(cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const focus = await acc.getMetaValue("focus_state");
-  const previousTask = focus?.currentTask ?? null;
-  if (!focus) {
-    return { previousTask: null };
-  }
-  const taskId = focus.currentTask;
-  const task = taskId ? await acc.loadSingleTask(taskId) : void 0;
-  focus.currentTask = null;
-  focus.nextAction = null;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  if (taskId && task) {
-    const { hooks: hooks2 } = await Promise.resolve().then(() => (init_registry(), registry_exports));
-    hooks2.dispatch("PostToolUse", cwd ?? process.cwd(), {
-      timestamp: now,
-      taskId,
-      taskTitle: task.title,
-      status: "done"
-    }).catch(() => {
-    });
-  }
-  await acc.setMetaValue("focus_state", focus);
-  await logOperation(
-    "task_stop",
-    previousTask ?? "none",
-    {
-      previousTask
-    },
-    accessor
-  );
-  return { previousTask };
-}
-async function getWorkHistory(cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const focus = await acc.getMetaValue("focus_state");
-  const notes = focus?.sessionNotes ?? [];
-  const history = [];
-  for (const note of notes) {
-    const match = note.note.match(/^(?:Focus set to|Started work on) (T\d+)/);
-    if (match) {
-      history.push({
-        taskId: match[1],
-        timestamp: note.timestamp
-      });
-    }
-  }
-  return history.reverse();
-}
-var getTaskHistory = getWorkHistory;
+// packages/core/src/index.ts
+init_task_work();
 
 // packages/core/src/tasks/index.ts
 var tasks_exports = {};
@@ -65656,6 +65956,7 @@ async function restoreSession(projectRoot, snapshot, options = {}, accessor) {
 
 // packages/core/src/cleo.ts
 init_data_accessor();
+init_task_work();
 init_add();
 init_complete();
 init_update2();
@@ -65880,7 +66181,14 @@ var Cleo = class _Cleo {
       discover: (p) => discoverRelated(p.query, p.method, p.limit),
       search: (p) => searchAcrossProjects(p.pattern, p.project, p.limit),
       setPermission: (p) => setPermission(p.name, p.level),
-      sharingStatus: () => getSharingStatus()
+      sharingStatus: () => getSharingStatus(),
+      route: (message) => {
+        const directive = parseDirective(message);
+        if (!directive) return Promise.resolve([]);
+        return routeDirective(directive);
+      },
+      workspaceStatus: () => workspaceStatus(),
+      workspaceAgents: () => workspaceAgents()
     };
   }
   // === Agents ===
@@ -65941,6 +66249,7 @@ init_registry();
 init_brain_retrieval();
 init_brain_search();
 init_sessions();
+init_task_work();
 init_add();
 init_complete();
 init_update2();