@cleocode/cleo 2026.3.73 → 2026.3.74

package/dist/cli/index.js

@@ -9,6 +9,55 @@ var __export = (target, all) => {
     __defProp(target, name2, { get: all[name2], enumerable: true });
 };
 
+// packages/cleo/src/cli/field-context.ts
+import {
+  resolveFieldExtraction
+} from "@cleocode/lafs-protocol";
+function setFieldContext(ctx) {
+  currentContext = ctx;
+}
+function getFieldContext() {
+  return currentContext;
+}
+function resolveFieldContext(opts) {
+  const input = {
+    fieldFlag: typeof opts["field"] === "string" ? opts["field"] : void 0,
+    fieldsFlag: typeof opts["fields"] === "string" ? opts["fields"] : void 0,
+    mviFlag: typeof opts["mvi"] === "string" ? opts["mvi"] : void 0
+  };
+  return resolveFieldExtraction(input);
+}
+var currentContext;
+var init_field_context = __esm({
+  "packages/cleo/src/cli/field-context.ts"() {
+    "use strict";
+    currentContext = {
+      mvi: "standard",
+      mviSource: "default",
+      expectsCustomMvi: false
+    };
+  }
+});
+
+// packages/cleo/src/cli/format-context.ts
+function setFormatContext(resolution) {
+  currentResolution = resolution;
+}
+function getFormatContext() {
+  return currentResolution;
+}
+var currentResolution;
+var init_format_context = __esm({
+  "packages/cleo/src/cli/format-context.ts"() {
+    "use strict";
+    currentResolution = {
+      format: "json",
+      source: "default",
+      quiet: false
+    };
+  }
+});
+
 // packages/contracts/src/errors.ts
 function normalizeError(error40, fallbackMessage = "An unexpected error occurred") {
   if (error40 instanceof Error) {
@@ -632,6 +681,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";
@@ -45251,8 +45307,8 @@ var init_checksum = __esm({
 });
 
 // packages/core/src/migration/logger.ts
-var logger_exports = {};
-__export(logger_exports, {
+var logger_exports2 = {};
+__export(logger_exports2, {
   MigrationLogger: () => MigrationLogger,
   createMigrationLogger: () => createMigrationLogger,
   getLatestMigrationLog: () => getLatestMigrationLog,
@@ -48205,6 +48261,903 @@ var init_transfer = __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 now2 = (/* @__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: now2,
+      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);
+}
+async function loadCompletionEnforcement(cwd) {
+  const isTest = !!process.env.VITEST;
+  const config2 = await loadConfig(cwd);
+  const acceptance = config2.enforcement?.acceptance;
+  const verificationCfg = config2.verification;
+  const acceptanceMode = acceptance?.mode ?? (isTest ? "off" : "block");
+  const acceptanceRequiredForPriorities = acceptance?.requiredForPriorities ?? (isTest ? [] : ["critical", "high", "medium", "low"]);
+  const rawVerificationEnabled = await getRawConfigValue("verification.enabled", cwd);
+  const verificationEnabled = rawVerificationEnabled !== void 0 ? rawVerificationEnabled : !isTest;
+  const verificationRequiredGates = (verificationCfg?.requiredGates ?? []).filter(isVerificationGate).length > 0 ? (verificationCfg?.requiredGates ?? []).filter(isVerificationGate) : DEFAULT_VERIFICATION_REQUIRED_GATES;
+  const verificationMaxRounds = verificationCfg?.maxRounds ?? 5;
+  const lifecycleMode = config2.lifecycle?.mode ?? (isTest ? "off" : "strict");
+  return {
+    acceptanceMode,
+    acceptanceRequiredForPriorities,
+    verificationEnabled,
+    verificationRequiredGates,
+    verificationMaxRounds,
+    lifecycleMode
+  };
+}
+async function completeTask(options, cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const task = await acc.loadSingleTask(options.taskId);
+  if (!task) {
+    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${options.taskId}`, {
+      fix: `Use 'cleo find "${options.taskId}"' to search`
+    });
+  }
+  await requireActiveSession("tasks.complete", cwd);
+  const enforcement = await loadCompletionEnforcement(cwd);
+  if (task.status === "done") {
+    throw new CleoError(17 /* TASK_COMPLETED */, `Task ${options.taskId} is already completed`);
+  }
+  if (task.depends?.length) {
+    const deps = await acc.loadTasks(task.depends);
+    const incompleteDeps = deps.filter((d) => d.status !== "done" && d.status !== "cancelled").map((d) => d.id);
+    if (incompleteDeps.length > 0) {
+      throw new CleoError(
+        5 /* DEPENDENCY_ERROR */,
+        `Task ${options.taskId} has incomplete dependencies: ${incompleteDeps.join(", ")}`,
+        {
+          fix: `Complete dependencies first: ${incompleteDeps.map((d) => `cleo complete ${d}`).join(", ")}`
+        }
+      );
+    }
+  }
+  const acceptanceEnforcement = await createAcceptanceEnforcement(cwd);
+  const completionValidation = acceptanceEnforcement.validateCompletion(task);
+  if (!completionValidation.valid) {
+    throw new CleoError(
+      completionValidation.exitCode ?? 6 /* VALIDATION_ERROR */,
+      completionValidation.error,
+      { fix: completionValidation.fix }
+    );
+  }
+  if (enforcement.verificationEnabled && task.type !== "epic") {
+    if (!task.verification) {
+      throw new CleoError(
+        40 /* VERIFICATION_INIT_FAILED */,
+        `Task ${options.taskId} is missing verification metadata`,
+        {
+          fix: `Initialize verification for ${options.taskId} before completion`
+        }
+      );
+    }
+    if (task.verification.round > enforcement.verificationMaxRounds) {
+      throw new CleoError(
+        44 /* MAX_ROUNDS_EXCEEDED */,
+        `Task ${options.taskId} exceeded verification max rounds (${enforcement.verificationMaxRounds})`,
+        {
+          fix: `Review failure log and resolve blockers before retrying completion`
+        }
+      );
+    }
+    const missingRequiredGates = enforcement.verificationRequiredGates.filter(
+      (gate) => task.verification?.gates?.[gate] !== true
+    );
+    if (missingRequiredGates.length > 0 || task.verification.passed !== true) {
+      const exitCode = enforcement.lifecycleMode === "strict" ? 80 /* LIFECYCLE_GATE_FAILED */ : 45 /* GATE_DEPENDENCY */;
+      throw new CleoError(
+        exitCode,
+        `Task ${options.taskId} failed verification gates: ${missingRequiredGates.join(", ") || "verification.passed=false"}`,
+        {
+          fix: `Set required verification gates before completion: ${enforcement.verificationRequiredGates.join(", ")}`
+        }
+      );
+    }
+  }
+  const children = await acc.getChildren(options.taskId);
+  const incompleteChildren = children.filter(
+    (c) => c.status !== "done" && c.status !== "cancelled"
+  );
+  if (incompleteChildren.length > 0 && task.type === "epic") {
+    if (!task.noAutoComplete) {
+      throw new CleoError(
+        16 /* HAS_CHILDREN */,
+        `Epic ${options.taskId} has ${incompleteChildren.length} incomplete children: ${incompleteChildren.map((c) => c.id).join(", ")}`,
+        {
+          fix: `Complete children first or use 'cleo update ${options.taskId} --no-auto-complete'`
+        }
+      );
+    }
+  }
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const before = { ...task };
+  task.status = "done";
+  task.completedAt = now2;
+  task.updatedAt = now2;
+  if (options.notes) {
+    const timestampedNote = `${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}: ${options.notes}`;
+    if (!task.notes) task.notes = [];
+    task.notes.push(timestampedNote);
+  }
+  if (options.changeset) {
+    if (!task.notes) task.notes = [];
+    task.notes.push(`Changeset: ${options.changeset}`);
+  }
+  const autoCompleted = [];
+  const autoCompletedTasks = [];
+  if (task.parentId) {
+    const parent = await acc.loadSingleTask(task.parentId);
+    if (parent && parent.type === "epic" && !parent.noAutoComplete) {
+      const siblings = await acc.getChildren(parent.id);
+      const allDone = siblings.every(
+        (c) => c.id === task.id || c.status === "done" || c.status === "cancelled"
+      );
+      if (allDone) {
+        parent.status = "done";
+        parent.completedAt = now2;
+        parent.updatedAt = now2;
+        autoCompleted.push(parent.id);
+        autoCompletedTasks.push(parent);
+      }
+    }
+  }
+  await acc.transaction(async (tx) => {
+    await tx.upsertSingleTask(task);
+    for (const parentTask of autoCompletedTasks) {
+      await tx.upsertSingleTask(parentTask);
+    }
+    await tx.appendLog({
+      id: `log-${Math.floor(Date.now() / 1e3)}-${(await import("node:crypto")).randomBytes(3).toString("hex")}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "task_completed",
+      taskId: options.taskId,
+      actor: "system",
+      details: { title: task.title, previousStatus: before.status },
+      before: null,
+      after: { title: task.title, previousStatus: before.status }
+    });
+  });
+  const dependents = await acc.getDependents(options.taskId);
+  const unblockedTasks = [];
+  for (const dep of dependents) {
+    if (dep.status === "done" || dep.status === "cancelled") continue;
+    if (dep.depends?.length) {
+      const depDeps = await acc.loadTasks(dep.depends);
+      const stillUnresolved = depDeps.filter(
+        (d) => d.id !== options.taskId && d.status !== "done" && d.status !== "cancelled"
+      );
+      if (stillUnresolved.length === 0) {
+        unblockedTasks.push({ id: dep.id, title: dep.title });
+      }
+    } else {
+      unblockedTasks.push({ id: dep.id, title: dep.title });
+    }
+  }
+  Promise.resolve().then(() => (init_auto_extract(), auto_extract_exports)).then(
+    ({ extractTaskCompletionMemory: extractTaskCompletionMemory2 }) => extractTaskCompletionMemory2(cwd ?? process.cwd(), task)
+  ).catch(() => {
+  });
+  return {
+    task,
+    ...autoCompleted.length > 0 && { autoCompleted },
+    ...unblockedTasks.length > 0 && { unblockedTasks }
+  };
+}
+var DEFAULT_VERIFICATION_REQUIRED_GATES, VERIFICATION_GATES;
+var init_complete = __esm({
+  "packages/core/src/tasks/complete.ts"() {
+    "use strict";
+    init_src();
+    init_config();
+    init_errors3();
+    init_session_enforcement();
+    init_data_accessor();
+    init_enforcement();
+    DEFAULT_VERIFICATION_REQUIRED_GATES = [
+      "implemented",
+      "testsPassed",
+      "qaPassed",
+      "securityPassed",
+      "documented"
+    ];
+    VERIFICATION_GATES = /* @__PURE__ */ new Set([
+      "implemented",
+      "testsPassed",
+      "qaPassed",
+      "cleanupDone",
+      "securityPassed",
+      "documented"
+    ]);
+  }
+});
+
+// packages/core/src/tasks/update.ts
+var update_exports = {};
+__export(update_exports, {
+  updateTask: () => updateTask
+});
+function hasNonStatusDoneFields(options) {
+  return NON_STATUS_DONE_FIELDS.some((field) => options[field] !== void 0);
+}
+async function updateTask(options, cwd, accessor) {
+  const acc = accessor ?? await getAccessor(cwd);
+  const task = await acc.loadSingleTask(options.taskId);
+  if (!task) {
+    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${options.taskId}`, {
+      fix: `Use 'cleo find "${options.taskId}"' to search`
+    });
+  }
+  await requireActiveSession("tasks.update", cwd);
+  const changes = [];
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  const isStatusOnlyDoneTransition = options.status === "done" && task.status !== "done" && !hasNonStatusDoneFields(options);
+  if (isStatusOnlyDoneTransition) {
+    const result = await completeTask({ taskId: options.taskId }, cwd, accessor);
+    return { task: result.task, changes: ["status"] };
+  }
+  if (options.status === "done" && task.status !== "done") {
+    throw new CleoError(
+      6 /* VALIDATION_ERROR */,
+      "status=done must use complete flow; do not combine with other update fields",
+      {
+        fix: `Run 'cleo complete ${options.taskId}' first, then apply additional updates with 'cleo update ${options.taskId} ...'`
+      }
+    );
+  }
+  const enforcement = await createAcceptanceEnforcement(cwd);
+  const updateValidation = enforcement.validateUpdate(task, { acceptance: options.acceptance });
+  if (!updateValidation.valid) {
+    throw new CleoError(
+      updateValidation.exitCode ?? 6 /* VALIDATION_ERROR */,
+      updateValidation.error,
+      { fix: updateValidation.fix }
+    );
+  }
+  if (options.title !== void 0) {
+    validateTitle(options.title);
+    task.title = options.title;
+    changes.push("title");
+  }
+  if (options.status !== void 0) {
+    validateStatus(options.status);
+    const oldStatus = task.status;
+    task.status = options.status;
+    changes.push("status");
+    if (options.status === "done" && oldStatus !== "done") {
+      task.completedAt = now2;
+    }
+    if (options.status === "cancelled" && oldStatus !== "cancelled") {
+      task.cancelledAt = now2;
+    }
+  }
+  if (options.priority !== void 0) {
+    const normalizedPriority = normalizePriority(options.priority);
+    task.priority = normalizedPriority;
+    changes.push("priority");
+  }
+  if (options.type !== void 0) {
+    validateTaskType(options.type);
+    task.type = options.type;
+    changes.push("type");
+  }
+  if (options.size !== void 0) {
+    validateSize(options.size);
+    task.size = options.size;
+    changes.push("size");
+  }
+  if (options.phase !== void 0) {
+    task.phase = options.phase;
+    changes.push("phase");
+  }
+  if (options.description !== void 0) {
+    task.description = options.description;
+    changes.push("description");
+  }
+  if (options.labels !== void 0) {
+    if (options.labels.length) validateLabels(options.labels);
+    task.labels = options.labels;
+    changes.push("labels");
+  }
+  if (options.addLabels?.length) {
+    validateLabels(options.addLabels);
+    const existing = new Set(task.labels ?? []);
+    for (const l of options.addLabels) existing.add(l.trim());
+    task.labels = [...existing];
+    changes.push("labels");
+  }
+  if (options.removeLabels?.length) {
+    const toRemove = new Set(options.removeLabels.map((l) => l.trim()));
+    task.labels = (task.labels ?? []).filter((l) => !toRemove.has(l));
+    changes.push("labels");
+  }
+  if (options.depends !== void 0) {
+    task.depends = options.depends;
+    changes.push("depends");
+  }
+  if (options.addDepends?.length) {
+    const existing = new Set(task.depends ?? []);
+    for (const d of options.addDepends) existing.add(d.trim());
+    task.depends = [...existing];
+    changes.push("depends");
+  }
+  if (options.removeDepends?.length) {
+    const toRemove = new Set(options.removeDepends.map((d) => d.trim()));
+    task.depends = (task.depends ?? []).filter((d) => !toRemove.has(d));
+    changes.push("depends");
+  }
+  if (options.notes !== void 0) {
+    const timestampedNote = `${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}: ${options.notes}`;
+    if (!task.notes) task.notes = [];
+    task.notes.push(timestampedNote);
+    changes.push("notes");
+  }
+  if (options.acceptance !== void 0) {
+    task.acceptance = options.acceptance;
+    changes.push("acceptance");
+  }
+  if (options.files !== void 0) {
+    task.files = options.files;
+    changes.push("files");
+  }
+  if (options.blockedBy !== void 0) {
+    task.blockedBy = options.blockedBy;
+    changes.push("blockedBy");
+  }
+  if (options.noAutoComplete !== void 0) {
+    task.noAutoComplete = options.noAutoComplete;
+    changes.push("noAutoComplete");
+  }
+  if (options.pipelineStage !== void 0) {
+    validatePipelineTransition(task.pipelineStage, options.pipelineStage);
+    if (task.type === "epic" && task.pipelineStage) {
+      await validateEpicStageAdvancement(
+        {
+          epicId: task.id,
+          currentStage: task.pipelineStage,
+          newStage: options.pipelineStage
+        },
+        acc,
+        cwd
+      );
+    }
+    if (task.type !== "epic") {
+      const epicAncestor = task.parentId ? await findEpicAncestor(task.parentId, acc) : null;
+      const directParent = task.parentId ? await acc.loadSingleTask(task.parentId) : null;
+      const epicToCheck = directParent?.type === "epic" ? directParent : epicAncestor;
+      if (epicToCheck) {
+        await validateChildStageCeiling(
+          { childStage: options.pipelineStage, epicId: epicToCheck.id },
+          acc,
+          cwd
+        );
+      }
+    }
+    task.pipelineStage = options.pipelineStage;
+    changes.push("pipelineStage");
+  }
+  if (options.parentId !== void 0) {
+    const newParentId = options.parentId || null;
+    const currentParentId = task.parentId ?? null;
+    if (newParentId !== currentParentId) {
+      const originalType = task.type;
+      if (!newParentId) {
+        task.parentId = null;
+        if (task.type === "subtask") task.type = "task";
+        changes.push("parentId");
+        if (task.type !== originalType) changes.push("type");
+      } else {
+        const newParent = await acc.loadSingleTask(newParentId);
+        if (!newParent) {
+          throw new CleoError(10 /* PARENT_NOT_FOUND */, `Parent task ${newParentId} not found`);
+        }
+        if (newParent.type === "subtask") {
+          throw new CleoError(
+            13 /* INVALID_PARENT_TYPE */,
+            `Cannot parent under subtask '${newParentId}'`
+          );
+        }
+        const subtree = await acc.getSubtree(options.taskId);
+        if (subtree.some((t) => t.id === newParentId)) {
+          throw new CleoError(
+            14 /* CIRCULAR_REFERENCE */,
+            `Moving '${options.taskId}' under '${newParentId}' would create a circular reference`
+          );
+        }
+        const ancestors = await acc.getAncestorChain(newParentId);
+        const parentDepth = ancestors.length;
+        const config2 = await loadConfig(cwd);
+        const policy = resolveHierarchyPolicy(config2);
+        if (parentDepth + 1 >= policy.maxDepth) {
+          throw new CleoError(
+            11 /* DEPTH_EXCEEDED */,
+            `Maximum nesting depth ${policy.maxDepth} would be exceeded`
+          );
+        }
+        task.parentId = newParentId;
+        const newDepth = parentDepth + 1;
+        if (newDepth === 1) task.type = "task";
+        else if (newDepth >= 2) task.type = "subtask";
+        changes.push("parentId");
+        if (task.type !== originalType) changes.push("type");
+      }
+    }
+  }
+  if (changes.length === 0) {
+    throw new CleoError(102 /* NO_CHANGE */, "No changes specified");
+  }
+  task.updatedAt = now2;
+  await acc.transaction(async (tx) => {
+    await tx.upsertSingleTask(task);
+    await tx.appendLog({
+      id: `log-${Math.floor(Date.now() / 1e3)}-${(await import("node:crypto")).randomBytes(3).toString("hex")}`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      action: "task_updated",
+      taskId: options.taskId,
+      actor: "system",
+      details: { changes, title: task.title },
+      before: null,
+      after: { changes, title: task.title }
+    });
+  });
+  return { task, changes };
+}
+var NON_STATUS_DONE_FIELDS;
+var init_update2 = __esm({
+  "packages/core/src/tasks/update.ts"() {
+    "use strict";
+    init_src();
+    init_config();
+    init_errors3();
+    init_session_enforcement();
+    init_data_accessor();
+    init_add();
+    init_complete();
+    init_enforcement();
+    init_epic_enforcement();
+    init_hierarchy_policy();
+    init_pipeline_stage();
+    NON_STATUS_DONE_FIELDS = [
+      "title",
+      "priority",
+      "type",
+      "size",
+      "phase",
+      "description",
+      "labels",
+      "addLabels",
+      "removeLabels",
+      "depends",
+      "addDepends",
+      "removeDepends",
+      "notes",
+      "acceptance",
+      "files",
+      "blockedBy",
+      "parentId",
+      "noAutoComplete",
+      "pipelineStage"
+    ];
+  }
+});
+
+// packages/core/src/nexus/workspace.ts
+function checkRateLimit(agentId) {
+  const now2 = Date.now();
+  const entry = rateLimitCounters.get(agentId);
+  if (!entry || now2 - entry.windowStart > RATE_LIMIT_WINDOW_MS) {
+    rateLimitCounters.set(agentId, { count: 1, windowStart: now2 });
+    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`
+    );
+  }
+}
+async function loadProjectACL(projectPath) {
+  try {
+    const { loadConfig: loadConfig4 } = await Promise.resolve().then(() => (init_config(), config_exports));
+    const config2 = await loadConfig4(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);
+}
+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
+  };
+}
+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: startTask3 } = await Promise.resolve().then(() => (init_task_work(), task_work_exports));
+      await startTask3(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: stopTask3 } = await Promise.resolve().then(() => (init_task_work(), task_work_exports));
+      await stopTask3(projectPath, accessor);
+      break;
+    }
+    case "tasks.update": {
+      const { updateTask: updateTask3 } = await Promise.resolve().then(() => (init_update2(), update_exports));
+      await updateTask3(
+        { 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 log11 = getLogger2("nexus.route");
+    const level = success2 ? "info" : "warn";
+    log11[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 counts2 = {
+        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: counts2,
+        health: project.healthStatus,
+        lastSync: project.lastSync
+      });
+      totals.pending += counts2.pending;
+      totals.active += counts2.active;
+      totals.done += counts2.done;
+      totals.total += counts2.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;
+}
+var RATE_LIMIT_WINDOW_MS, RATE_LIMIT_MAX_OPS, rateLimitCounters, DEFAULT_ACL, TASK_REF_PATTERN, VERB_TO_OPERATION;
+var init_workspace = __esm({
+  "packages/core/src/nexus/workspace.ts"() {
+    "use strict";
+    init_src();
+    init_errors3();
+    init_data_accessor();
+    init_registry3();
+    RATE_LIMIT_WINDOW_MS = 6e4;
+    RATE_LIMIT_MAX_OPS = 100;
+    rateLimitCounters = /* @__PURE__ */ new Map();
+    DEFAULT_ACL = { authorizedAgents: ["*"] };
+    TASK_REF_PATTERN = /\bT(\d+)\b/g;
+    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"
+    };
+  }
+});
+
 // packages/core/src/nexus/index.ts
 var nexus_exports = {};
 __export(nexus_exports, {
@@ -48239,6 +49192,7 @@ __export(nexus_exports, {
   nexusSyncAll: () => nexusSyncAll,
   nexusUnregister: () => nexusUnregister,
   orphanDetection: () => orphanDetection,
+  parseDirective: () => parseDirective,
   parseQuery: () => parseQuery,
   permissionLevel: () => permissionLevel,
   previewTransfer: () => previewTransfer,
@@ -48249,10 +49203,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
 });
 var init_nexus = __esm({
   "packages/core/src/nexus/index.ts"() {
@@ -48265,6 +49222,7 @@ var init_nexus = __esm({
     init_registry3();
     init_sharing();
     init_transfer();
+    init_workspace();
   }
 });
 
@@ -49606,676 +50564,197 @@ async function advancePhase(force = false, _cwd, accessor) {
         6 /* VALIDATION_ERROR */,
         `Cannot advance - ${criticalTasks.length} critical task(s) remain in phase '${currentSlug}'`
       );
-    }
-    const totalTasks = phaseTasks.length;
-    const completionPercent = totalTasks > 0 ? Math.floor((totalTasks - incompleteTasks.length) * 100 / totalTasks) : 0;
-    const threshold = 90;
-    if (completionPercent < threshold && !force) {
-      throw new CleoError(
-        6 /* VALIDATION_ERROR */,
-        `Cannot advance - ${incompleteTasks.length} incomplete task(s) in phase '${currentSlug}' (${completionPercent}% complete, threshold: ${threshold}%)`,
-        { fix: "Use --force to override" }
-      );
-    }
-  }
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  currentPhase.status = "completed";
-  currentPhase.completedAt = now2;
-  const nextPhase = phases[nextSlug];
-  nextPhase.status = "active";
-  nextPhase.startedAt = now2;
-  const updatedMeta = meta;
-  updatedMeta.currentPhase = nextSlug;
-  const currentPhaseTaskCount = phaseTasks.length;
-  const { tasks: nextPhaseTasks } = await accessor.queryTasks({ phase: nextSlug });
-  const nextPhaseTaskCount = nextPhaseTasks.length;
-  addPhaseHistoryEntryToMeta(
-    updatedMeta,
-    currentSlug,
-    "completed",
-    null,
-    "Phase completed via advance",
-    currentPhaseTaskCount
-  );
-  addPhaseHistoryEntryToMeta(
-    updatedMeta,
-    nextSlug,
-    "started",
-    currentSlug,
-    `Phase started via advance from ${currentSlug}`,
-    nextPhaseTaskCount
-  );
-  await accessor.setMetaValue("project_meta", updatedMeta);
-  return {
-    previousPhase: currentSlug,
-    currentPhase: nextSlug,
-    forced: force
-  };
-}
-async function renamePhase(oldName, newName, _cwd, accessor) {
-  const meta = await accessor.getMetaValue("project_meta");
-  const phases = meta?.phases ?? {};
-  if (!phases[oldName]) {
-    throw new CleoError(4 /* NOT_FOUND */, `Phase '${oldName}' does not exist`);
-  }
-  if (phases[newName]) {
-    throw new CleoError(101 /* ALREADY_EXISTS */, `Phase '${newName}' already exists`);
-  }
-  if (!/^[a-z][a-z0-9-]*$/.test(newName)) {
-    throw new CleoError(2 /* INVALID_INPUT */, `Invalid phase name '${newName}'`);
-  }
-  phases[newName] = phases[oldName];
-  delete phases[oldName];
-  const { tasks: oldPhaseTasks } = await accessor.queryTasks({ phase: oldName });
-  let tasksUpdated = 0;
-  for (const task of oldPhaseTasks) {
-    task.phase = newName;
-    await accessor.upsertSingleTask(task);
-    tasksUpdated++;
-  }
-  const updatedMeta = meta;
-  let currentPhaseUpdated = false;
-  if (updatedMeta.currentPhase === oldName) {
-    updatedMeta.currentPhase = newName;
-    currentPhaseUpdated = true;
-  }
-  await accessor.setMetaValue("project_meta", updatedMeta);
-  const focus = await accessor.getMetaValue("focus_state");
-  if (focus?.currentPhase === oldName) {
-    focus.currentPhase = newName;
-    await accessor.setMetaValue("focus_state", focus);
-  }
-  return { oldName, newName, tasksUpdated, currentPhaseUpdated };
-}
-async function deletePhase(slug, options = {}, _cwd, accessor) {
-  const meta = await accessor.getMetaValue("project_meta");
-  const phases = meta?.phases ?? {};
-  if (!phases[slug]) {
-    throw new CleoError(4 /* NOT_FOUND */, `Phase '${slug}' does not exist`);
-  }
-  if (meta?.currentPhase === slug) {
-    throw new CleoError(
-      6 /* VALIDATION_ERROR */,
-      `Cannot delete current project phase '${slug}'. Use 'phase set' to change phase first`
-    );
-  }
-  const { tasks: phaseTasks } = await accessor.queryTasks({ phase: slug });
-  if (phaseTasks.length > 0 && !options.reassignTo) {
-    throw new CleoError(
-      6 /* VALIDATION_ERROR */,
-      `Cannot delete '${slug}': ${phaseTasks.length} tasks would be orphaned. Use --reassign-to <phase>`
-    );
-  }
-  if (!options.force) {
-    throw new CleoError(2 /* INVALID_INPUT */, "Phase deletion requires --force flag for safety");
-  }
-  if (options.reassignTo) {
-    if (!phases[options.reassignTo]) {
-      throw new CleoError(
-        4 /* NOT_FOUND */,
-        `Reassignment target phase '${options.reassignTo}' does not exist`
-      );
-    }
-  }
-  let tasksReassigned = 0;
-  if (options.reassignTo) {
-    for (const task of phaseTasks) {
-      task.phase = options.reassignTo;
-      await accessor.upsertSingleTask(task);
-      tasksReassigned++;
-    }
-  }
-  delete phases[slug];
-  await accessor.setMetaValue("project_meta", meta);
-  return {
-    deletedPhase: slug,
-    tasksReassigned,
-    reassignedTo: options.reassignTo ?? null
-  };
-}
-function addPhaseHistoryEntryToMeta(meta, phase, transitionType, fromPhase, reason, taskCount) {
-  if (!meta.phaseHistory) {
-    meta.phaseHistory = [];
-  }
-  meta.phaseHistory.push({
-    phase,
-    transitionType,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    taskCount,
-    fromPhase,
-    reason
-  });
-}
-var init_phases = __esm({
-  "packages/core/src/phases/index.ts"() {
-    "use strict";
-    init_src();
-    init_errors3();
-    init_add();
-  }
-});
-
-// packages/core/src/pipeline/phase.ts
-async function listPhases2(projectRoot, accessor) {
-  try {
-    const result = await listPhases(projectRoot, accessor);
-    return { success: true, data: result };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return {
-      success: false,
-      error: { code: "E_PHASE_LIST_FAILED", message }
-    };
-  }
-}
-async function showPhase2(projectRoot, phaseId, accessor) {
-  try {
-    const result = await showPhase(phaseId, projectRoot, accessor);
-    return { success: true, data: result };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return {
-      success: false,
-      error: { code: "E_PHASE_SHOW_FAILED", message }
-    };
-  }
-}
-var init_phase = __esm({
-  "packages/core/src/pipeline/phase.ts"() {
-    "use strict";
-    init_phases();
-  }
-});
-
-// packages/core/src/pipeline/index.ts
-var pipeline_exports2 = {};
-__export(pipeline_exports2, {
-  listPhases: () => listPhases2,
-  showPhase: () => showPhase2
-});
-var init_pipeline2 = __esm({
-  "packages/core/src/pipeline/index.ts"() {
-    "use strict";
-    init_phase();
-  }
-});
-
-// packages/core/src/tasks/complete.ts
-function isVerificationGate(value) {
-  return VERIFICATION_GATES.has(value);
-}
-async function loadCompletionEnforcement(cwd) {
-  const isTest = !!process.env.VITEST;
-  const config2 = await loadConfig(cwd);
-  const acceptance = config2.enforcement?.acceptance;
-  const verificationCfg = config2.verification;
-  const acceptanceMode = acceptance?.mode ?? (isTest ? "off" : "block");
-  const acceptanceRequiredForPriorities = acceptance?.requiredForPriorities ?? (isTest ? [] : ["critical", "high", "medium", "low"]);
-  const rawVerificationEnabled = await getRawConfigValue("verification.enabled", cwd);
-  const verificationEnabled = rawVerificationEnabled !== void 0 ? rawVerificationEnabled : !isTest;
-  const verificationRequiredGates = (verificationCfg?.requiredGates ?? []).filter(isVerificationGate).length > 0 ? (verificationCfg?.requiredGates ?? []).filter(isVerificationGate) : DEFAULT_VERIFICATION_REQUIRED_GATES;
-  const verificationMaxRounds = verificationCfg?.maxRounds ?? 5;
-  const lifecycleMode = config2.lifecycle?.mode ?? (isTest ? "off" : "strict");
-  return {
-    acceptanceMode,
-    acceptanceRequiredForPriorities,
-    verificationEnabled,
-    verificationRequiredGates,
-    verificationMaxRounds,
-    lifecycleMode
-  };
-}
-async function completeTask(options, cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const task = await acc.loadSingleTask(options.taskId);
-  if (!task) {
-    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${options.taskId}`, {
-      fix: `Use 'cleo find "${options.taskId}"' to search`
-    });
-  }
-  await requireActiveSession("tasks.complete", cwd);
-  const enforcement = await loadCompletionEnforcement(cwd);
-  if (task.status === "done") {
-    throw new CleoError(17 /* TASK_COMPLETED */, `Task ${options.taskId} is already completed`);
-  }
-  if (task.depends?.length) {
-    const deps = await acc.loadTasks(task.depends);
-    const incompleteDeps = deps.filter((d) => d.status !== "done" && d.status !== "cancelled").map((d) => d.id);
-    if (incompleteDeps.length > 0) {
-      throw new CleoError(
-        5 /* DEPENDENCY_ERROR */,
-        `Task ${options.taskId} has incomplete dependencies: ${incompleteDeps.join(", ")}`,
-        {
-          fix: `Complete dependencies first: ${incompleteDeps.map((d) => `cleo complete ${d}`).join(", ")}`
-        }
-      );
-    }
-  }
-  const acceptanceEnforcement = await createAcceptanceEnforcement(cwd);
-  const completionValidation = acceptanceEnforcement.validateCompletion(task);
-  if (!completionValidation.valid) {
-    throw new CleoError(
-      completionValidation.exitCode ?? 6 /* VALIDATION_ERROR */,
-      completionValidation.error,
-      { fix: completionValidation.fix }
-    );
-  }
-  if (enforcement.verificationEnabled && task.type !== "epic") {
-    if (!task.verification) {
-      throw new CleoError(
-        40 /* VERIFICATION_INIT_FAILED */,
-        `Task ${options.taskId} is missing verification metadata`,
-        {
-          fix: `Initialize verification for ${options.taskId} before completion`
-        }
-      );
-    }
-    if (task.verification.round > enforcement.verificationMaxRounds) {
-      throw new CleoError(
-        44 /* MAX_ROUNDS_EXCEEDED */,
-        `Task ${options.taskId} exceeded verification max rounds (${enforcement.verificationMaxRounds})`,
-        {
-          fix: `Review failure log and resolve blockers before retrying completion`
-        }
-      );
-    }
-    const missingRequiredGates = enforcement.verificationRequiredGates.filter(
-      (gate) => task.verification?.gates?.[gate] !== true
-    );
-    if (missingRequiredGates.length > 0 || task.verification.passed !== true) {
-      const exitCode = enforcement.lifecycleMode === "strict" ? 80 /* LIFECYCLE_GATE_FAILED */ : 45 /* GATE_DEPENDENCY */;
-      throw new CleoError(
-        exitCode,
-        `Task ${options.taskId} failed verification gates: ${missingRequiredGates.join(", ") || "verification.passed=false"}`,
-        {
-          fix: `Set required verification gates before completion: ${enforcement.verificationRequiredGates.join(", ")}`
-        }
-      );
-    }
-  }
-  const children = await acc.getChildren(options.taskId);
-  const incompleteChildren = children.filter(
-    (c) => c.status !== "done" && c.status !== "cancelled"
-  );
-  if (incompleteChildren.length > 0 && task.type === "epic") {
-    if (!task.noAutoComplete) {
-      throw new CleoError(
-        16 /* HAS_CHILDREN */,
-        `Epic ${options.taskId} has ${incompleteChildren.length} incomplete children: ${incompleteChildren.map((c) => c.id).join(", ")}`,
-        {
-          fix: `Complete children first or use 'cleo update ${options.taskId} --no-auto-complete'`
-        }
-      );
-    }
-  }
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const before = { ...task };
-  task.status = "done";
-  task.completedAt = now2;
-  task.updatedAt = now2;
-  if (options.notes) {
-    const timestampedNote = `${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}: ${options.notes}`;
-    if (!task.notes) task.notes = [];
-    task.notes.push(timestampedNote);
-  }
-  if (options.changeset) {
-    if (!task.notes) task.notes = [];
-    task.notes.push(`Changeset: ${options.changeset}`);
-  }
-  const autoCompleted = [];
-  const autoCompletedTasks = [];
-  if (task.parentId) {
-    const parent = await acc.loadSingleTask(task.parentId);
-    if (parent && parent.type === "epic" && !parent.noAutoComplete) {
-      const siblings = await acc.getChildren(parent.id);
-      const allDone = siblings.every(
-        (c) => c.id === task.id || c.status === "done" || c.status === "cancelled"
-      );
-      if (allDone) {
-        parent.status = "done";
-        parent.completedAt = now2;
-        parent.updatedAt = now2;
-        autoCompleted.push(parent.id);
-        autoCompletedTasks.push(parent);
-      }
-    }
-  }
-  await acc.transaction(async (tx) => {
-    await tx.upsertSingleTask(task);
-    for (const parentTask of autoCompletedTasks) {
-      await tx.upsertSingleTask(parentTask);
-    }
-    await tx.appendLog({
-      id: `log-${Math.floor(Date.now() / 1e3)}-${(await import("node:crypto")).randomBytes(3).toString("hex")}`,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      action: "task_completed",
-      taskId: options.taskId,
-      actor: "system",
-      details: { title: task.title, previousStatus: before.status },
-      before: null,
-      after: { title: task.title, previousStatus: before.status }
-    });
-  });
-  const dependents = await acc.getDependents(options.taskId);
-  const unblockedTasks = [];
-  for (const dep of dependents) {
-    if (dep.status === "done" || dep.status === "cancelled") continue;
-    if (dep.depends?.length) {
-      const depDeps = await acc.loadTasks(dep.depends);
-      const stillUnresolved = depDeps.filter(
-        (d) => d.id !== options.taskId && d.status !== "done" && d.status !== "cancelled"
-      );
-      if (stillUnresolved.length === 0) {
-        unblockedTasks.push({ id: dep.id, title: dep.title });
-      }
-    } else {
-      unblockedTasks.push({ id: dep.id, title: dep.title });
-    }
-  }
-  Promise.resolve().then(() => (init_auto_extract(), auto_extract_exports)).then(
-    ({ extractTaskCompletionMemory: extractTaskCompletionMemory2 }) => extractTaskCompletionMemory2(cwd ?? process.cwd(), task)
-  ).catch(() => {
-  });
-  return {
-    task,
-    ...autoCompleted.length > 0 && { autoCompleted },
-    ...unblockedTasks.length > 0 && { unblockedTasks }
-  };
-}
-var DEFAULT_VERIFICATION_REQUIRED_GATES, VERIFICATION_GATES;
-var init_complete = __esm({
-  "packages/core/src/tasks/complete.ts"() {
-    "use strict";
-    init_src();
-    init_config();
-    init_errors3();
-    init_session_enforcement();
-    init_data_accessor();
-    init_enforcement();
-    DEFAULT_VERIFICATION_REQUIRED_GATES = [
-      "implemented",
-      "testsPassed",
-      "qaPassed",
-      "securityPassed",
-      "documented"
-    ];
-    VERIFICATION_GATES = /* @__PURE__ */ new Set([
-      "implemented",
-      "testsPassed",
-      "qaPassed",
-      "cleanupDone",
-      "securityPassed",
-      "documented"
-    ]);
-  }
-});
-
-// packages/core/src/tasks/update.ts
-var update_exports = {};
-__export(update_exports, {
-  updateTask: () => updateTask
-});
-function hasNonStatusDoneFields(options) {
-  return NON_STATUS_DONE_FIELDS.some((field) => options[field] !== void 0);
-}
-async function updateTask(options, cwd, accessor) {
-  const acc = accessor ?? await getAccessor(cwd);
-  const task = await acc.loadSingleTask(options.taskId);
-  if (!task) {
-    throw new CleoError(4 /* NOT_FOUND */, `Task not found: ${options.taskId}`, {
-      fix: `Use 'cleo find "${options.taskId}"' to search`
-    });
-  }
-  await requireActiveSession("tasks.update", cwd);
-  const changes = [];
-  const now2 = (/* @__PURE__ */ new Date()).toISOString();
-  const isStatusOnlyDoneTransition = options.status === "done" && task.status !== "done" && !hasNonStatusDoneFields(options);
-  if (isStatusOnlyDoneTransition) {
-    const result = await completeTask({ taskId: options.taskId }, cwd, accessor);
-    return { task: result.task, changes: ["status"] };
-  }
-  if (options.status === "done" && task.status !== "done") {
-    throw new CleoError(
-      6 /* VALIDATION_ERROR */,
-      "status=done must use complete flow; do not combine with other update fields",
-      {
-        fix: `Run 'cleo complete ${options.taskId}' first, then apply additional updates with 'cleo update ${options.taskId} ...'`
-      }
-    );
-  }
-  const enforcement = await createAcceptanceEnforcement(cwd);
-  const updateValidation = enforcement.validateUpdate(task, { acceptance: options.acceptance });
-  if (!updateValidation.valid) {
-    throw new CleoError(
-      updateValidation.exitCode ?? 6 /* VALIDATION_ERROR */,
-      updateValidation.error,
-      { fix: updateValidation.fix }
-    );
-  }
-  if (options.title !== void 0) {
-    validateTitle(options.title);
-    task.title = options.title;
-    changes.push("title");
-  }
-  if (options.status !== void 0) {
-    validateStatus(options.status);
-    const oldStatus = task.status;
-    task.status = options.status;
-    changes.push("status");
-    if (options.status === "done" && oldStatus !== "done") {
-      task.completedAt = now2;
-    }
-    if (options.status === "cancelled" && oldStatus !== "cancelled") {
-      task.cancelledAt = now2;
-    }
-  }
-  if (options.priority !== void 0) {
-    const normalizedPriority = normalizePriority(options.priority);
-    task.priority = normalizedPriority;
-    changes.push("priority");
-  }
-  if (options.type !== void 0) {
-    validateTaskType(options.type);
-    task.type = options.type;
-    changes.push("type");
-  }
-  if (options.size !== void 0) {
-    validateSize(options.size);
-    task.size = options.size;
-    changes.push("size");
-  }
-  if (options.phase !== void 0) {
-    task.phase = options.phase;
-    changes.push("phase");
-  }
-  if (options.description !== void 0) {
-    task.description = options.description;
-    changes.push("description");
-  }
-  if (options.labels !== void 0) {
-    if (options.labels.length) validateLabels(options.labels);
-    task.labels = options.labels;
-    changes.push("labels");
+    }
+    const totalTasks = phaseTasks.length;
+    const completionPercent = totalTasks > 0 ? Math.floor((totalTasks - incompleteTasks.length) * 100 / totalTasks) : 0;
+    const threshold = 90;
+    if (completionPercent < threshold && !force) {
+      throw new CleoError(
+        6 /* VALIDATION_ERROR */,
+        `Cannot advance - ${incompleteTasks.length} incomplete task(s) in phase '${currentSlug}' (${completionPercent}% complete, threshold: ${threshold}%)`,
+        { fix: "Use --force to override" }
+      );
+    }
   }
-  if (options.addLabels?.length) {
-    validateLabels(options.addLabels);
-    const existing = new Set(task.labels ?? []);
-    for (const l of options.addLabels) existing.add(l.trim());
-    task.labels = [...existing];
-    changes.push("labels");
+  const now2 = (/* @__PURE__ */ new Date()).toISOString();
+  currentPhase.status = "completed";
+  currentPhase.completedAt = now2;
+  const nextPhase = phases[nextSlug];
+  nextPhase.status = "active";
+  nextPhase.startedAt = now2;
+  const updatedMeta = meta;
+  updatedMeta.currentPhase = nextSlug;
+  const currentPhaseTaskCount = phaseTasks.length;
+  const { tasks: nextPhaseTasks } = await accessor.queryTasks({ phase: nextSlug });
+  const nextPhaseTaskCount = nextPhaseTasks.length;
+  addPhaseHistoryEntryToMeta(
+    updatedMeta,
+    currentSlug,
+    "completed",
+    null,
+    "Phase completed via advance",
+    currentPhaseTaskCount
+  );
+  addPhaseHistoryEntryToMeta(
+    updatedMeta,
+    nextSlug,
+    "started",
+    currentSlug,
+    `Phase started via advance from ${currentSlug}`,
+    nextPhaseTaskCount
+  );
+  await accessor.setMetaValue("project_meta", updatedMeta);
+  return {
+    previousPhase: currentSlug,
+    currentPhase: nextSlug,
+    forced: force
+  };
+}
+async function renamePhase(oldName, newName, _cwd, accessor) {
+  const meta = await accessor.getMetaValue("project_meta");
+  const phases = meta?.phases ?? {};
+  if (!phases[oldName]) {
+    throw new CleoError(4 /* NOT_FOUND */, `Phase '${oldName}' does not exist`);
   }
-  if (options.removeLabels?.length) {
-    const toRemove = new Set(options.removeLabels.map((l) => l.trim()));
-    task.labels = (task.labels ?? []).filter((l) => !toRemove.has(l));
-    changes.push("labels");
+  if (phases[newName]) {
+    throw new CleoError(101 /* ALREADY_EXISTS */, `Phase '${newName}' already exists`);
   }
-  if (options.depends !== void 0) {
-    task.depends = options.depends;
-    changes.push("depends");
+  if (!/^[a-z][a-z0-9-]*$/.test(newName)) {
+    throw new CleoError(2 /* INVALID_INPUT */, `Invalid phase name '${newName}'`);
   }
-  if (options.addDepends?.length) {
-    const existing = new Set(task.depends ?? []);
-    for (const d of options.addDepends) existing.add(d.trim());
-    task.depends = [...existing];
-    changes.push("depends");
+  phases[newName] = phases[oldName];
+  delete phases[oldName];
+  const { tasks: oldPhaseTasks } = await accessor.queryTasks({ phase: oldName });
+  let tasksUpdated = 0;
+  for (const task of oldPhaseTasks) {
+    task.phase = newName;
+    await accessor.upsertSingleTask(task);
+    tasksUpdated++;
   }
-  if (options.removeDepends?.length) {
-    const toRemove = new Set(options.removeDepends.map((d) => d.trim()));
-    task.depends = (task.depends ?? []).filter((d) => !toRemove.has(d));
-    changes.push("depends");
+  const updatedMeta = meta;
+  let currentPhaseUpdated = false;
+  if (updatedMeta.currentPhase === oldName) {
+    updatedMeta.currentPhase = newName;
+    currentPhaseUpdated = true;
   }
-  if (options.notes !== void 0) {
-    const timestampedNote = `${(/* @__PURE__ */ new Date()).toISOString().replace("T", " ").replace(/\.\d+Z$/, " UTC")}: ${options.notes}`;
-    if (!task.notes) task.notes = [];
-    task.notes.push(timestampedNote);
-    changes.push("notes");
+  await accessor.setMetaValue("project_meta", updatedMeta);
+  const focus = await accessor.getMetaValue("focus_state");
+  if (focus?.currentPhase === oldName) {
+    focus.currentPhase = newName;
+    await accessor.setMetaValue("focus_state", focus);
   }
-  if (options.acceptance !== void 0) {
-    task.acceptance = options.acceptance;
-    changes.push("acceptance");
+  return { oldName, newName, tasksUpdated, currentPhaseUpdated };
+}
+async function deletePhase(slug, options = {}, _cwd, accessor) {
+  const meta = await accessor.getMetaValue("project_meta");
+  const phases = meta?.phases ?? {};
+  if (!phases[slug]) {
+    throw new CleoError(4 /* NOT_FOUND */, `Phase '${slug}' does not exist`);
   }
-  if (options.files !== void 0) {
-    task.files = options.files;
-    changes.push("files");
+  if (meta?.currentPhase === slug) {
+    throw new CleoError(
+      6 /* VALIDATION_ERROR */,
+      `Cannot delete current project phase '${slug}'. Use 'phase set' to change phase first`
+    );
   }
-  if (options.blockedBy !== void 0) {
-    task.blockedBy = options.blockedBy;
-    changes.push("blockedBy");
+  const { tasks: phaseTasks } = await accessor.queryTasks({ phase: slug });
+  if (phaseTasks.length > 0 && !options.reassignTo) {
+    throw new CleoError(
+      6 /* VALIDATION_ERROR */,
+      `Cannot delete '${slug}': ${phaseTasks.length} tasks would be orphaned. Use --reassign-to <phase>`
+    );
   }
-  if (options.noAutoComplete !== void 0) {
-    task.noAutoComplete = options.noAutoComplete;
-    changes.push("noAutoComplete");
+  if (!options.force) {
+    throw new CleoError(2 /* INVALID_INPUT */, "Phase deletion requires --force flag for safety");
   }
-  if (options.pipelineStage !== void 0) {
-    validatePipelineTransition(task.pipelineStage, options.pipelineStage);
-    if (task.type === "epic" && task.pipelineStage) {
-      await validateEpicStageAdvancement(
-        {
-          epicId: task.id,
-          currentStage: task.pipelineStage,
-          newStage: options.pipelineStage
-        },
-        acc,
-        cwd
+  if (options.reassignTo) {
+    if (!phases[options.reassignTo]) {
+      throw new CleoError(
+        4 /* NOT_FOUND */,
+        `Reassignment target phase '${options.reassignTo}' does not exist`
       );
     }
-    if (task.type !== "epic") {
-      const epicAncestor = task.parentId ? await findEpicAncestor(task.parentId, acc) : null;
-      const directParent = task.parentId ? await acc.loadSingleTask(task.parentId) : null;
-      const epicToCheck = directParent?.type === "epic" ? directParent : epicAncestor;
-      if (epicToCheck) {
-        await validateChildStageCeiling(
-          { childStage: options.pipelineStage, epicId: epicToCheck.id },
-          acc,
-          cwd
-        );
-      }
-    }
-    task.pipelineStage = options.pipelineStage;
-    changes.push("pipelineStage");
   }
-  if (options.parentId !== void 0) {
-    const newParentId = options.parentId || null;
-    const currentParentId = task.parentId ?? null;
-    if (newParentId !== currentParentId) {
-      const originalType = task.type;
-      if (!newParentId) {
-        task.parentId = null;
-        if (task.type === "subtask") task.type = "task";
-        changes.push("parentId");
-        if (task.type !== originalType) changes.push("type");
-      } else {
-        const newParent = await acc.loadSingleTask(newParentId);
-        if (!newParent) {
-          throw new CleoError(10 /* PARENT_NOT_FOUND */, `Parent task ${newParentId} not found`);
-        }
-        if (newParent.type === "subtask") {
-          throw new CleoError(
-            13 /* INVALID_PARENT_TYPE */,
-            `Cannot parent under subtask '${newParentId}'`
-          );
-        }
-        const subtree = await acc.getSubtree(options.taskId);
-        if (subtree.some((t) => t.id === newParentId)) {
-          throw new CleoError(
-            14 /* CIRCULAR_REFERENCE */,
-            `Moving '${options.taskId}' under '${newParentId}' would create a circular reference`
-          );
-        }
-        const ancestors = await acc.getAncestorChain(newParentId);
-        const parentDepth = ancestors.length;
-        const config2 = await loadConfig(cwd);
-        const policy = resolveHierarchyPolicy(config2);
-        if (parentDepth + 1 >= policy.maxDepth) {
-          throw new CleoError(
-            11 /* DEPTH_EXCEEDED */,
-            `Maximum nesting depth ${policy.maxDepth} would be exceeded`
-          );
-        }
-        task.parentId = newParentId;
-        const newDepth = parentDepth + 1;
-        if (newDepth === 1) task.type = "task";
-        else if (newDepth >= 2) task.type = "subtask";
-        changes.push("parentId");
-        if (task.type !== originalType) changes.push("type");
-      }
+  let tasksReassigned = 0;
+  if (options.reassignTo) {
+    for (const task of phaseTasks) {
+      task.phase = options.reassignTo;
+      await accessor.upsertSingleTask(task);
+      tasksReassigned++;
     }
   }
-  if (changes.length === 0) {
-    throw new CleoError(102 /* NO_CHANGE */, "No changes specified");
+  delete phases[slug];
+  await accessor.setMetaValue("project_meta", meta);
+  return {
+    deletedPhase: slug,
+    tasksReassigned,
+    reassignedTo: options.reassignTo ?? null
+  };
+}
+function addPhaseHistoryEntryToMeta(meta, phase, transitionType, fromPhase, reason, taskCount) {
+  if (!meta.phaseHistory) {
+    meta.phaseHistory = [];
   }
-  task.updatedAt = now2;
-  await acc.transaction(async (tx) => {
-    await tx.upsertSingleTask(task);
-    await tx.appendLog({
-      id: `log-${Math.floor(Date.now() / 1e3)}-${(await import("node:crypto")).randomBytes(3).toString("hex")}`,
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      action: "task_updated",
-      taskId: options.taskId,
-      actor: "system",
-      details: { changes, title: task.title },
-      before: null,
-      after: { changes, title: task.title }
-    });
+  meta.phaseHistory.push({
+    phase,
+    transitionType,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    taskCount,
+    fromPhase,
+    reason
   });
-  return { task, changes };
 }
-var NON_STATUS_DONE_FIELDS;
-var init_update2 = __esm({
-  "packages/core/src/tasks/update.ts"() {
+var init_phases = __esm({
+  "packages/core/src/phases/index.ts"() {
     "use strict";
     init_src();
-    init_config();
     init_errors3();
-    init_session_enforcement();
-    init_data_accessor();
     init_add();
-    init_complete();
-    init_enforcement();
-    init_epic_enforcement();
-    init_hierarchy_policy();
-    init_pipeline_stage();
-    NON_STATUS_DONE_FIELDS = [
-      "title",
-      "priority",
-      "type",
-      "size",
-      "phase",
-      "description",
-      "labels",
-      "addLabels",
-      "removeLabels",
-      "depends",
-      "addDepends",
-      "removeDepends",
-      "notes",
-      "acceptance",
-      "files",
-      "blockedBy",
-      "parentId",
-      "noAutoComplete",
-      "pipelineStage"
-    ];
+  }
+});
+
+// packages/core/src/pipeline/phase.ts
+async function listPhases2(projectRoot, accessor) {
+  try {
+    const result = await listPhases(projectRoot, accessor);
+    return { success: true, data: result };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      error: { code: "E_PHASE_LIST_FAILED", message }
+    };
+  }
+}
+async function showPhase2(projectRoot, phaseId, accessor) {
+  try {
+    const result = await showPhase(phaseId, projectRoot, accessor);
+    return { success: true, data: result };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      error: { code: "E_PHASE_SHOW_FAILED", message }
+    };
+  }
+}
+var init_phase = __esm({
+  "packages/core/src/pipeline/phase.ts"() {
+    "use strict";
+    init_phases();
+  }
+});
+
+// packages/core/src/pipeline/index.ts
+var pipeline_exports2 = {};
+__export(pipeline_exports2, {
+  listPhases: () => listPhases2,
+  showPhase: () => showPhase2
+});
+var init_pipeline2 = __esm({
+  "packages/core/src/pipeline/index.ts"() {
+    "use strict";
+    init_phase();
   }
 });
 
@@ -62663,145 +63142,6 @@ var init_system2 = __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 now2 = (/* @__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: now2,
-      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/archive.ts
 async function archiveTasks(options = {}, cwd, accessor) {
   const acc = accessor ?? await getAccessor(cwd);
@@ -63964,12 +64304,12 @@ function parseCommonFlags(args) {
   flags.remaining = remaining;
   return flags;
 }
-function resolveFormat(flagFormat) {
+function resolveFormat2(flagFormat) {
   if (flagFormat === "json" || flagFormat === "human") return flagFormat;
   return process.stdout.isTTY ? "human" : "json";
 }
 function isJsonOutput(flags) {
-  return resolveFormat(flags.format) === "json";
+  return resolveFormat2(flags.format) === "json";
 }
 var init_flags = __esm({
   "packages/core/src/ui/flags.ts"() {
@@ -64004,7 +64344,7 @@ __export(ui_exports, {
   parseCommandHeader: () => parseCommandHeader,
   parseCommonFlags: () => parseCommonFlags,
   removeAliases: () => removeAliases,
-  resolveFormat: () => resolveFormat,
+  resolveFormat: () => resolveFormat2,
   scanAllCommands: () => scanAllCommands,
   validateHeader: () => validateHeader,
   writeChangelogFile: () => writeChangelogFile
@@ -68333,6 +68673,7 @@ var init_cleo = __esm({
     init_permissions();
     init_registry3();
     init_sharing();
+    init_workspace();
     init_orchestration();
     init_reconciliation();
     init_link_store();
@@ -68571,7 +68912,14 @@ var init_cleo = __esm({
           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 ===
@@ -75933,7 +76281,7 @@ async function runUpgrade(options = {}) {
           return { success: false, upToDate: false, dryRun: isDryRun, actions, applied: 0, errors };
         }
         await forceCheckpointBeforeOperation("storage-migration", options.cwd);
-        const { MigrationLogger: MigrationLogger2 } = await Promise.resolve().then(() => (init_logger3(), logger_exports));
+        const { MigrationLogger: MigrationLogger2 } = await Promise.resolve().then(() => (init_logger3(), logger_exports2));
         const {
           createMigrationState: createMigrationState2,
           updateMigrationPhase: updateMigrationPhase2,
@@ -80487,41 +80835,6 @@ var init_internal = __esm({
   }
 });
 
-// packages/cleo/src/cli/field-context.ts
-import {
-  resolveFieldExtraction
-} from "@cleocode/lafs-protocol";
-function getFieldContext() {
-  return currentContext;
-}
-var currentContext;
-var init_field_context = __esm({
-  "packages/cleo/src/cli/field-context.ts"() {
-    "use strict";
-    currentContext = {
-      mvi: "standard",
-      mviSource: "default",
-      expectsCustomMvi: false
-    };
-  }
-});
-
-// packages/cleo/src/cli/format-context.ts
-function getFormatContext() {
-  return currentResolution;
-}
-var currentResolution;
-var init_format_context = __esm({
-  "packages/cleo/src/cli/format-context.ts"() {
-    "use strict";
-    currentResolution = {
-      format: "json",
-      source: "default",
-      quiet: false
-    };
-  }
-});
-
 // packages/cleo/src/cli/renderers/normalizer.ts
 function normalizeForHuman(command, data) {
   switch (command) {
@@ -95457,6 +95770,23 @@ function camelToKebab(str) {
   return str.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
 }
 
+// packages/cleo/src/cli/index.ts
+init_field_context();
+init_format_context();
+
+// packages/cleo/src/cli/middleware/output-format.ts
+import { resolveOutputFormat } from "@cleocode/lafs-protocol";
+function resolveFormat(opts, defaults) {
+  const input = {
+    jsonFlag: opts["json"] === true,
+    humanFlag: opts["human"] === true,
+    quiet: opts["quiet"] === true,
+    projectDefault: defaults?.projectDefault,
+    userDefault: defaults?.userDefault
+  };
+  return resolveOutputFormat(input);
+}
+
 // packages/cleo/src/cli/commands/add.ts
 init_cli();
 init_renderers();
@@ -101394,6 +101724,28 @@ for (const shim of rootShim._subcommands) {
     subCommands[alias] = shimToCitty(shim);
   }
 }
+{
+  const argv = process.argv.slice(2);
+  const rawOpts = {};
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") rawOpts["json"] = true;
+    else if (arg === "--human") rawOpts["human"] = true;
+    else if (arg === "--quiet") rawOpts["quiet"] = true;
+    else if (arg === "--field" && i + 1 < argv.length) rawOpts["field"] = argv[++i];
+    else if (arg === "--fields" && i + 1 < argv.length) rawOpts["fields"] = argv[++i];
+    else if (arg === "--mvi" && i + 1 < argv.length) rawOpts["mvi"] = argv[++i];
+  }
+  const formatResolution = resolveFormat(rawOpts);
+  setFormatContext(formatResolution);
+  const fieldResolution = resolveFieldContext(rawOpts);
+  setFieldContext(fieldResolution);
+  if (argv[0] === "-V") {
+    const { cliOutput: cliOutput2 } = await Promise.resolve().then(() => (init_renderers(), renderers_exports));
+    cliOutput2({ version: CLI_VERSION }, { command: "version" });
+    process.exit(0);
+  }
+}
 if (process.argv[2] === "mcp") {
   const mcpPath = join119(import.meta.dirname ?? "", "..", "mcp", "index.js");
   const { spawn: spawn3 } = await import("node:child_process");