diff --git a/src/app.d.ts b/src/app.d.ts
index aff83e967e..cfcca1c2d8 100644
--- a/src/app.d.ts
+++ b/src/app.d.ts
@@ -71,7 +71,6 @@ declare global {
     parameterDictionaries: ParameterDictionary[],
     channelDictionary: ChannelDictionary | null,
   );
-  var ALLOW_NON_COMMAND_STEPS: boolean | undefined;
 }
 
 export {};
diff --git a/src/components/sequencing/form/SelectedCommand.svelte b/src/components/sequencing/form/SelectedCommand.svelte
index 3ef2d8f60f..63f38b2deb 100644
--- a/src/components/sequencing/form/SelectedCommand.svelte
+++ b/src/components/sequencing/form/SelectedCommand.svelte
@@ -1,6 +1,7 @@
 <svelte:options immutable={true} />
 
 <script lang="ts">
+  import type { EditorState } from '@codemirror/state';
   import type { SyntaxNode } from '@lezer/common';
   import type {
     ChannelDictionary,
@@ -8,7 +9,6 @@
     FswCommand,
     FswCommandArgument,
     FswCommandArgumentRepeat,
-    FswCommandArgumentVarString,
     ParameterDictionary,
   } from '@nasa-jpl/aerie-ampcs';
   import type { EditorView } from 'codemirror';
@@ -20,19 +20,10 @@
     type ArgTextDef,
   } from '../../../utilities/codemirror/codemirror-utils';
   import { getCustomArgDef } from '../../../utilities/new-sequence-editor/extension-points';
-  import {
-    getNameNode,
-    TOKEN_ACTIVATE,
-    TOKEN_COMMAND,
-    TOKEN_ERROR,
-    TOKEN_GROUND_BLOCK,
-    TOKEN_GROUND_EVENT,
-    TOKEN_LOAD,
-  } from '../../../utilities/new-sequence-editor/sequencer-grammar-constants';
+  import { TOKEN_COMMAND, TOKEN_ERROR } from '../../../utilities/new-sequence-editor/sequencer-grammar-constants';
   import { getAncestorNode } from '../../../utilities/new-sequence-editor/tree-utils';
   import AddMissingArgsButton from './AddMissingArgsButton.svelte';
   import ArgEditor from './ArgEditor.svelte';
-  import StringEditor from './StringEditor.svelte';
 
   type TimeTagInfo = { node: SyntaxNode; text: string } | null | undefined;
 
@@ -51,17 +42,8 @@
   let missingArgDefArray: FswCommandArgument[] = [];
   let timeTagNode: TimeTagInfo = null;
 
-  $: commandNode = getAncestorNode(
-    node,
-    TOKEN_COMMAND,
-    TOKEN_ACTIVATE,
-    TOKEN_GROUND_BLOCK,
-    TOKEN_GROUND_EVENT,
-    TOKEN_LOAD,
-  );
-  $: commandNameNode = getNameNode(commandNode);
-  $: commandName = commandNameNode && editorSequenceView.state.sliceDoc(commandNameNode.from, commandNameNode.to);
-  $: commandDef = getCommandDef(commandDictionary, commandName ?? '');
+  $: commandNode = getAncestorNode(node, TOKEN_COMMAND);
+  $: commandDef = getCommandDef(commandDictionary, editorSequenceView.state, commandNode);
   $: argInfoArray = getArgumentInfo(
     commandNode?.getChild('Args') ?? null,
     commandDef?.arguments,
@@ -150,8 +132,23 @@
     return argArray;
   }
 
-  function getCommandDef(commandDictionary: CommandDictionary | null, stemName: string) {
-    return commandDictionary?.fswCommandMap[stemName] ?? null;
+  function getCommandDef(
+    commandDictionary: CommandDictionary | null,
+    state: EditorState | undefined,
+    commandNode: SyntaxNode | null,
+  ) {
+    if (!commandDictionary || !state || !node) {
+      return null;
+    }
+
+    const stemNode = commandNode?.getChild('Stem');
+
+    if (stemNode) {
+      const stemName = state.sliceDoc(stemNode.from, stemNode.to);
+      return commandDictionary.fswCommandMap[stemName];
+    }
+
+    return null;
   }
 
   function setInEditor(token: SyntaxNode, val: string) {
@@ -184,21 +181,6 @@
     return hasAncestorWithId(element.parentElement, id);
   }
 
-  function formatTypeName(s: string) {
-    // add spaces to CamelCase names, 'GroundEvent' -> 'Ground Event'
-    return s.replace(/([^A-Z])(?=[A-Z])/g, '$1 ');
-  }
-
-  const nameArgumentDef: FswCommandArgumentVarString = {
-    arg_type: 'var_string',
-    default_value: null,
-    description: '',
-    max_bit_length: null,
-    name: '',
-    prefix_bit_length: null,
-    valid_regex: null,
-  };
-
   // When the type in the argument value is compatible with the argument definition,
   // provide a more restrictive editor to keep argument valid. Otherwise fall back on a string editor.
 
@@ -211,9 +193,8 @@
 
 <div class="select-command-detail" id={ID_COMMAND_DETAIL_PANE}>
   {#if !!commandNode}
+    <div>Selected Command</div>
     {#if !!commandDef}
-      <div>Selected {formatTypeName(commandNode.name)}</div>
-
       {#if !!timeTagNode}
         <div>Time Tag: {timeTagNode.text.trim()}</div>
       {/if}
@@ -244,22 +225,6 @@
           />
         {/if}
       </div>
-    {:else}
-      <div>Selected {formatTypeName(commandNode.name)}</div>
-      {#if !!timeTagNode}
-        <div>Time Tag: {timeTagNode.text.trim()}</div>
-      {/if}
-      <div>
-        <StringEditor
-          argDef={nameArgumentDef}
-          initVal={commandName ?? ''}
-          setInEditor={val => {
-            if (commandNameNode) {
-              setInEditor(commandNameNode, val);
-            }
-          }}
-        />
-      </div>
     {/if}
   {/if}
 </div>
diff --git a/src/utilities/codemirror/codemirror-utils.ts b/src/utilities/codemirror/codemirror-utils.ts
index fdf3d55595..bf1e1686f5 100644
--- a/src/utilities/codemirror/codemirror-utils.ts
+++ b/src/utilities/codemirror/codemirror-utils.ts
@@ -126,9 +126,6 @@ export function quoteEscape(s: string) {
   return `"${s.replaceAll('"', '\\"')}"`;
 }
 
-export function removeEscapedQuotes(text: string): string;
-export function removeEscapedQuotes(text: number): number;
-export function removeEscapedQuotes(text: boolean): boolean;
 export function removeEscapedQuotes(text: string | number | boolean): string | number | boolean {
   if (typeof text === 'string') {
     return text.replace(/\\"|"(?!\\")/g, '"').trim();
diff --git a/src/utilities/codemirror/index.ts b/src/utilities/codemirror/index.ts
index 9312e91ec0..8bd75b1059 100644
--- a/src/utilities/codemirror/index.ts
+++ b/src/utilities/codemirror/index.ts
@@ -25,26 +25,18 @@ export const SeqLanguage = LRLanguage.define({
         Command: customFoldInside,
       }),
       styleTags({
-        Activate: t.namespace,
         Boolean: t.bool,
-        Engine: t.namespace,
-        Epoch: t.namespace,
         GenericDirective: t.namespace,
         Global: t.namespace,
-        GroundBlock: t.namespace,
-        GroundEpoch: t.className,
-        GroundEvent: t.namespace,
         HardwareCommands: t.namespace,
         IdDeclaration: t.namespace,
         ImmediateCommands: t.namespace,
         LineComment: t.comment,
-        Load: t.namespace,
         LoadAndGoDirective: t.namespace,
         LocalDeclaration: t.namespace,
         MetaEntry: t.namespace,
         Model: t.namespace,
         ParameterDeclaration: t.namespace,
-        Request: t.namespace,
         Stem: t.keyword,
         String: t.string,
         TimeAbsolute: t.className,
diff --git a/src/utilities/codemirror/sequence.grammar b/src/utilities/codemirror/sequence.grammar
index f70f4028ea..96766a5b17 100644
--- a/src/utilities/codemirror/sequence.grammar
+++ b/src/utilities/codemirror/sequence.grammar
@@ -13,6 +13,7 @@
 
 // Potential Improvements
 // maintainability - use @specialize on directives
+// expressiveness - add activate, load and ground syntax
 
 @precedence {
   stemStart @cut
@@ -35,15 +36,9 @@ LocalDeclaration {
 }
 
 commandBlock {
-  (
-    step |
-    Request |
-    commentLine ~maybeComments
-  )+
+  (Command | commentLine ~maybeComments)+
 }
 
-step { Command | Activate | GroundBlock | GroundEvent | Load }
-
 commentLine {
   LineComment newLine
 }
@@ -89,57 +84,6 @@ Command {
   Models?
 }
 
-Activate { TimeTag activateDirective commonLoadActivate }
-
-Load { TimeTag loadDirective commonLoadActivate }
-
-commonLoadActivate {
-  "(" SequenceName { String } ")"
-  Args
-  LineComment?
-  newLine
-  Engine { engineDirective whiteSpace Number newLine }?
-  Epoch { epochDirective whiteSpace String newLine }?
-  Metadata?
-  Models?
-}
-
-GroundBlock { TimeTag groundBlockDirective commonGround }
-
-GroundEvent { TimeTag groundEventDirective commonGround }
-
-commonGround {
-  "(" GroundName { String } ")"
-  Args
-  LineComment?
-  newLine
-  Metadata?
-  Models?
-}
-
-Request {
-  (TimeTag | GroundEpoch {
-    groundEpochDirective
-    "("
-      whiteSpace?
-      Name { String }
-      whiteSpace?
-    ","
-      whiteSpace?
-      Delta { String }
-      whiteSpace?
-    ")"
-    // Extra properties are allowed in schema, but not supported by tool chain
-    whiteSpace
-  })
-  requestStartDirective "(" RequestName { String } ")"
-  whiteSpace? LineComment? newLine
-  // json schema requires step+, catch error in linter for cleaner message
-  Steps { step* }
-  requestEndDirective newLine
-  Metadata?
-}
-
 Metadata {
   MetaEntry {
     metadataDirective
@@ -220,15 +164,6 @@ Stem { !stemStart identifier }
   hardwareDirective { "@HARDWARE" }
   localsDirective { "@LOCALS" }
   parameterDirective { "@INPUT_PARAMS" }
-  activateDirective { "@ACTIVATE" }
-  loadDirective { "@LOAD" }
-  engineDirective { "@ENGINE" }
-  epochDirective { "@EPOCH" }
-  groundEpochDirective { "@GROUND_EPOCH" }
-  groundBlockDirective { "@GROUND_BLOCK" }
-  groundEventDirective { "@GROUND_EVENT" }
-  requestStartDirective { "@REQUEST_BEGIN" }
-  requestEndDirective { "@REQUEST_END" }
   metadataDirective { "@METADATA" }
   modelDirective { "@MODEL" }
   genericDirective { "@"identifier }
@@ -238,7 +173,6 @@ Stem { !stemStart identifier }
   @precedence{ TimeAbsolute, TimeRelative, TimeEpoch, TimeComplete, identifier }
 
   @precedence {
-    LoadAndGoDirective,
     idDirective,
     metadataDirective,
     modelDirective,
@@ -246,15 +180,7 @@ Stem { !stemStart identifier }
     hardwareDirective,
     localsDirective,
     parameterDirective,
-    activateDirective,
-    loadDirective,
-    groundBlockDirective,
-    groundEventDirective,
-    groundEpochDirective,
-    requestStartDirective,
-    requestEndDirective,
-    engineDirective,
-    epochDirective,
+    LoadAndGoDirective,
     genericDirective,
     identifier
   }
diff --git a/src/utilities/new-sequence-editor/from-seq-json.test.ts b/src/utilities/new-sequence-editor/from-seq-json.test.ts
index 4db0d684fd..cc2660118b 100644
--- a/src/utilities/new-sequence-editor/from-seq-json.test.ts
+++ b/src/utilities/new-sequence-editor/from-seq-json.test.ts
@@ -555,156 +555,6 @@ E-00:00:01.000 FSE_CMD 10 "ENUM"
     expect(sequence).toEqual(expectedSequence);
   });
 
-  it('converts a quoted string', () => {
-    const seqJson: SeqJson = {
-      id: 'escaped_quotes',
-      metadata: {},
-      steps: [
-        {
-          args: [
-            {
-              type: 'string',
-              value: 'Can this handle " Escaped" quotes??',
-            },
-          ],
-          description: 'Can this handle "escape"',
-          stem: 'ECHO',
-          time: {
-            type: 'COMMAND_COMPLETE',
-          },
-          type: 'command',
-        },
-        {
-          args: [
-            {
-              type: 'string',
-              value: '"Can" this handle leading and trailing Escaped" quotes??"',
-            },
-          ],
-          description: '"Can" "this" handle "escape"',
-          stem: 'ECHO2',
-          time: {
-            type: 'COMMAND_COMPLETE',
-          },
-          type: 'command',
-        },
-      ],
-    };
-
-    const sequence = seqJsonToSequence(seqJson, [], null);
-    const expectedSequence = `@ID "escaped_quotes"
-
-C ECHO "Can this handle \\" Escaped\\" quotes??" # Can this handle "escape"
-C ECHO2 "\\"Can\\" this handle leading and trailing Escaped\\" quotes??\\"" # "Can" "this" handle "escape"
-`;
-    expect(sequence).toEqual(expectedSequence);
-  });
-
-  it('should convert activate', () => {
-    const seqJson: SeqJson = {
-      id: 'id',
-      metadata: {},
-      steps: [
-        {
-          args: [],
-          description: 'No Args',
-          engine: 10,
-          epoch: 'epoch string',
-          sequence: 'activate.name',
-          time: {
-            tag: '2024-123T12:34:56',
-            type: 'ABSOLUTE',
-          },
-          type: 'activate',
-        },
-      ],
-    };
-
-    const sequence = seqJsonToSequence(seqJson, [], null);
-    const expectedSequence = `
-@ID "id"
-
-A2024-123T12:34:56 @ACTIVATE("activate.name") # No Args
-@ENGINE 10
-@EPOCH "epoch string"
-`;
-    expect(sequence.trim()).toEqual(expectedSequence.trim());
-  });
-
-  it('should convert load', () => {
-    const seqJson: SeqJson = {
-      id: 'id',
-      metadata: {},
-      steps: [
-        {
-          args: [],
-          engine: 10,
-          epoch: 'epoch string',
-          sequence: 'load.name',
-          time: {
-            tag: '2024-123T12:34:56',
-            type: 'ABSOLUTE',
-          },
-          type: 'load',
-        },
-      ],
-    };
-
-    const sequence = seqJsonToSequence(seqJson, [], null);
-    const expectedSequence = `
-@ID "id"
-
-A2024-123T12:34:56 @LOAD("load.name")
-@ENGINE 10
-@EPOCH "epoch string"
-`;
-    expect(sequence.trim()).toEqual(expectedSequence.trim());
-  });
-
-  it('should convert ground event', () => {
-    const seqJson: SeqJson = {
-      id: 'id',
-      metadata: {},
-      steps: [
-        {
-          args: [
-            {
-              type: 'string',
-              value: 'foo',
-            },
-            {
-              type: 'number',
-              value: 1,
-            },
-            {
-              type: 'number',
-              value: 2,
-            },
-            {
-              type: 'number',
-              value: 3,
-            },
-          ],
-          name: 'ground_event.name',
-          time: {
-            tag: '123T11:55:33',
-            type: 'COMMAND_RELATIVE',
-          },
-          type: 'ground_event',
-        },
-      ],
-    };
-
-    const sequence = seqJsonToSequence(seqJson, [], null);
-
-    const expectedSequence = `
-@ID "id"
-
-R123T11:55:33 @GROUND_EVENT("ground_event.name") "foo" 1 2 3
-`;
-    expect(sequence.trim()).toEqual(expectedSequence.trim());
-  });
-
   it('converts a seq json empty repeat args to sequence', () => {
     const seqJson: SeqJson = {
       id: 'testRepeat',
@@ -757,91 +607,14 @@ R123T11:55:33 @GROUND_EVENT("ground_event.name") "foo" 1 2 3
       ],
     };
 
+    const sequence = seqJsonToSequence(seqJson, [], null);
     const expectedSequence = `@ID "testRepeat"
 
 C FSA_CMD 10 [] "USA" ["96707-898" "92604-623"]
 `;
-
-    const sequence = seqJsonToSequence(seqJson, [], null);
     expect(sequence).toEqual(expectedSequence);
   });
 
-  it('should convert requests to seq format', () => {
-    const seqJson: SeqJson = {
-      id: 'id',
-      metadata: {},
-      requests: [
-        {
-          ground_epoch: {
-            delta: '+3:00',
-            name: 'GroundEpochName',
-          },
-          metadata: {
-            req_0_meta_name: 'req_0_meta_value',
-          },
-          name: 'request2.name',
-          steps: [
-            {
-              args: [
-                {
-                  type: 'number',
-                  value: 1,
-                },
-                {
-                  type: 'number',
-                  value: 2,
-                },
-                {
-                  type: 'number',
-                  value: 3,
-                },
-              ],
-              metadata: {
-                cmd_0_meta_name_0: 'cmd_0_meta_value_0',
-              },
-              models: [{ offset: '00:00:00', value: 1, variable: 'a' }],
-              stem: 'CMD_0',
-              time: {
-                type: 'COMMAND_COMPLETE',
-              },
-              type: 'command',
-            },
-
-            {
-              args: [
-                {
-                  type: 'string',
-                  value: '1 2 3',
-                },
-              ],
-              stem: 'CMD_1',
-              time: {
-                tag: '00:01:40',
-                type: 'COMMAND_RELATIVE',
-              },
-              type: 'command',
-            },
-          ],
-          type: 'request',
-        },
-      ],
-    };
-    const sequence = seqJsonToSequence(seqJson, [], null);
-    const expectedSequence = `
-    @ID "id"
-    @GROUND_EPOCH("GroundEpochName", "+3:00") @REQUEST_BEGIN("request2.name")
-      C CMD_0 1 2 3
-      @METADATA "cmd_0_meta_name_0" "cmd_0_meta_value_0"
-      @MODEL "a" 1 "00:00:00"
-
-      R00:01:40 CMD_1 "1 2 3"
-
-    @REQUEST_END
-    @METADATA "req_0_meta_name" "req_0_meta_value"
-    `;
-    expect(normalizeWhitespace(sequence)).toEqual(normalizeWhitespace(expectedSequence));
-  });
-
   it('converts a quoted string', () => {
     const seqJson: SeqJson = {
       id: 'escaped_quotes',
@@ -887,10 +660,3 @@ C ECHO2 "\\"Can\\" this handle leading and trailing Escaped\\" quotes??\\"" # "C
     expect(sequence).toEqual(expectedSequence);
   });
 });
-
-function normalizeWhitespace(s: string) {
-  return s
-    .replace(/[ \t]+/g, ' ')
-    .replace(/\s*\n\s*/g, '\n')
-    .trim();
-}
diff --git a/src/utilities/new-sequence-editor/from-seq-json.ts b/src/utilities/new-sequence-editor/from-seq-json.ts
index 39e4ee1443..1e8a8b83db 100644
--- a/src/utilities/new-sequence-editor/from-seq-json.ts
+++ b/src/utilities/new-sequence-editor/from-seq-json.ts
@@ -1,18 +1,12 @@
 import type { ChannelDictionary, ParameterDictionary } from '@nasa-jpl/aerie-ampcs';
 import type {
-  Activate,
   Args,
   BooleanArgument,
-  Command,
   Description,
-  GroundBlock,
-  GroundEvent,
   HexArgument,
-  Load,
   Metadata,
   Model,
   NumberArgument,
-  Request,
   SeqJson,
   StringArgument,
   SymbolArgument,
@@ -29,13 +23,13 @@ import { logError } from './logger';
 export function seqJsonTimeToSequence(time: Time): string {
   switch (time.type) {
     case 'ABSOLUTE':
-      return `A${time.tag ?? ''}`;
+      return `A${time?.tag ?? ''}`;
     case 'COMMAND_COMPLETE':
       return 'C';
     case 'COMMAND_RELATIVE':
-      return `R${time.tag ?? ''}`;
+      return `R${time?.tag ?? ''}`;
     case 'EPOCH_RELATIVE':
-      return `E${time.tag ?? ''}`;
+      return `E${time?.tag ?? ''}`;
     default:
       return '';
   }
@@ -169,26 +163,25 @@ export function seqJsonToSequence(
       sequence.push(`\n@LOAD_AND_GO`);
     }
 
-    // command, activate, load, ground block, ground event
+    // FSW Commands
     if (seqJson.steps) {
       sequence.push(`\n`);
       for (const step of seqJson.steps) {
-        switch (step.type) {
-          case 'command': {
-            // FSW Commands
-            sequence.push(commandToString(step));
-            break;
-          }
-          case 'activate':
-          case 'load': {
-            sequence.push(loadOrActivateToString(step));
-            break;
-          }
-          case 'ground_block':
-          case 'ground_event': {
-            sequence.push(groundToString(step));
-            break;
+        if (step.type === 'command') {
+          const time = seqJsonTimeToSequence(step.time);
+          const args = seqJsonArgsToSequence(step.args);
+          const metadata = step.metadata ? seqJsonMetadataToSequence(step.metadata) : '';
+          const models = step.models ? seqJsonModelsToSequence(step.models) : '';
+          const description = step.description ? seqJsonDescriptionToSequence(step.description) : '';
+
+          let commandString = `${time} ${step.stem}${args}${description}`;
+          // add a new line if on doesn't exit at the end of the commandString
+          if (!commandString.endsWith('\n')) {
+            commandString += '\n';
           }
+          // Add modeling data if it exists
+          commandString += `${metadata}${models}`;
+          sequence.push(commandString);
         }
       }
     }
@@ -229,105 +222,11 @@ export function seqJsonToSequence(
         sequence.push(hardwareString);
       }
     }
-
-    // requests
-    if (seqJson.requests) {
-      for (const request of seqJson.requests) {
-        sequence.push(`\n`);
-        sequence.push(requestToString(request));
-      }
-    }
   }
 
   return sequence.join('');
 }
 
-function commandToString(step: Command) {
-  const time = seqJsonTimeToSequence(step.time);
-  const args = seqJsonArgsToSequence(step.args);
-  const metadata = step.metadata ? seqJsonMetadataToSequence(step.metadata) : '';
-  const models = step.models ? seqJsonModelsToSequence(step.models) : '';
-  const description = step.description ? seqJsonDescriptionToSequence(step.description) : '';
-
-  let commandString = `${time} ${step.stem}${args}${description}`;
-  // add a new line if on doesn't exit at the end of the commandString
-  if (!commandString.endsWith('\n')) {
-    commandString += '\n';
-  }
-  // Add modeling data if it exists
-  commandString += `${metadata}${models}`;
-  return commandString;
-}
-
-function loadOrActivateToString(step: Activate | Load) {
-  const time = seqJsonTimeToSequence(step.time);
-  const args = step.args ? seqJsonArgsToSequence(step.args) : '';
-  const metadata = step.metadata ? seqJsonMetadataToSequence(step.metadata) : '';
-  const models = step.models ? seqJsonModelsToSequence(step.models) : '';
-  const engine = step.engine !== undefined ? `@ENGINE ${step.engine.toString(10)}\n` : '';
-  const epoch = step.epoch !== undefined ? `@EPOCH ${quoteEscape(step.epoch)}\n` : '';
-  const description = step.description ? seqJsonDescriptionToSequence(step.description) : '';
-  const stepType = `@${step.type === 'activate' ? 'ACTIVATE' : 'LOAD'}(${quoteEscape(step.sequence)})`;
-  let stepString = `${time} ${stepType}${args}${description}`;
-  if (!stepString.endsWith('\n')) {
-    stepString += '\n';
-  }
-  stepString += `${engine}${epoch}${metadata}${models}`;
-  return stepString;
-}
-
-function groundToString(step: GroundBlock | GroundEvent) {
-  const time = seqJsonTimeToSequence(step.time);
-  const args = step.args ? seqJsonArgsToSequence(step.args) : '';
-  const metadata = step.metadata ? seqJsonMetadataToSequence(step.metadata) : '';
-  const models = step.models ? seqJsonModelsToSequence(step.models) : '';
-  const description = step.description ? seqJsonDescriptionToSequence(step.description) : '';
-  const stepType = `@${step.type === 'ground_block' ? 'GROUND_BLOCK' : 'GROUND_EVENT'}(${quoteEscape(step.name)})`;
-  let stepString = `${time} ${stepType}${args}${description}`;
-  if (!stepString.endsWith('\n')) {
-    stepString += '\n';
-  }
-  stepString += `${metadata}${models}`;
-  return stepString;
-}
-
-function requestToString(request: Request) {
-  let time = '';
-  if (request.time) {
-    time = seqJsonTimeToSequence(request.time);
-  } else if (request.ground_epoch) {
-    time = `@GROUND_EPOCH(${quoteEscape(request.ground_epoch.name ?? '')}, ${quoteEscape(request.ground_epoch.delta ?? '')})`;
-  }
-  const reqBegin = `@REQUEST_BEGIN(${quoteEscape(request.name)})`;
-  const description = request.description ? seqJsonDescriptionToSequence(request.description) : '';
-  let requestString = `${time} ${reqBegin}${description}`;
-  if (!requestString.endsWith('\n')) {
-    requestString += '\n';
-  }
-  const steps: string[] = [];
-  for (const step of request.steps) {
-    switch (step.type) {
-      case 'command': {
-        steps.push(commandToString(step));
-        break;
-      }
-      case 'activate':
-      case 'load': {
-        steps.push(loadOrActivateToString(step));
-        break;
-      }
-      case 'ground_block':
-      case 'ground_event': {
-        steps.push(groundToString(step));
-        break;
-      }
-    }
-  }
-  const metadata = request.metadata ? seqJsonMetadataToSequence(request.metadata) : '';
-  requestString += `${steps.join('')}@REQUEST_END\n${metadata}`;
-  return requestString;
-}
-
 /**
  * Return a parsed sequence JSON from a file.
  */
diff --git a/src/utilities/new-sequence-editor/grammar.test.ts b/src/utilities/new-sequence-editor/grammar.test.ts
index 4871895050..3b04935076 100644
--- a/src/utilities/new-sequence-editor/grammar.test.ts
+++ b/src/utilities/new-sequence-editor/grammar.test.ts
@@ -314,100 +314,6 @@ Command(Stem,Args(String),Models(Model(Variable(String),Value(String),Offset(Str
 )
 )`,
   ],
-  [
-    `Seq.Json comprehension`,
-    `A2024-123T12:34:56 @GROUND_BLOCK("ground_block.name") # No Args
-
-R123T12:34:56 @GROUND_EVENT("ground_event.name") "foo" 1 2 3
-
-A2024-123T12:34:56 @ACTIVATE("activate.name") # No Args
-@ENGINE 10
-@EPOCH "epoch string"
-
-R123T12:34:56 @ACTIVATE("act2.name") "foo" 1 2 3  # Comment
-@ENGINE -1
-
-
-A2024-321T11:22:33 @LOAD("load.name") # No Args
-@ENGINE 10
-@EPOCH "epoch string"
-
-R123T12:34:56 @LOAD("load2.name") "foo" 1 2 3  # A comment
-@ENGINE -1
-
-@GROUND_EPOCH("Name","+3:00") @REQUEST_BEGIN("request.name") # Description Text
-  C CMD_0 1 2 3
-  @METADATA "foo" "bar"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
-
-  C CMD_2 1 2 3
-
-  R100 CMD_3 "1 2 3"
-
-@REQUEST_END
-@METADATA "sub_object" {
-  "boolean": true
-}
-
-
-A2024-123T12:34:56 @REQUEST_BEGIN("request2.name")
-  C CMD_0 1 2 3
-  @METADATA "foo" "bar"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
-
-  C CMD_2 1 2 3
-
-  R100 CMD_3 "1 2 3"
-
-  C CMD_4 1 2 3
-
-  R100 CMD_5 "1 2 3"
-
-@REQUEST_END
-@METADATA "foo" "bar"
-`,
-    `
-Sequence(Commands(
-  GroundBlock(TimeTag(TimeAbsolute),GroundName(String),Args,LineComment),
-  GroundEvent(TimeTag(TimeRelative),GroundName(String),Args(String,Number,Number,Number)),
-
-  Activate(TimeTag(TimeAbsolute),SequenceName(String),Args,LineComment,Engine(Number),Epoch(String)),
-  Activate(TimeTag(TimeRelative),SequenceName(String),Args(String,Number,Number,Number),LineComment,Engine(Number)),
-
-  Load(TimeTag(TimeAbsolute),SequenceName(String),Args,LineComment,Engine(Number),Epoch(String)),
-  Load(TimeTag(TimeRelative),SequenceName(String),Args(String,Number,Number,Number),LineComment,Engine(Number)),
-
-  Request(
-    GroundEpoch(Name(String),Delta(String)),
-    RequestName(String),LineComment,
-    Steps(
-      Command(TimeTag(TimeComplete),Stem,Args(Number,Number,Number),Metadata(MetaEntry(Key(String),Value(String))),Models(Model(Variable(String),Value(Number),Offset(String)))),
-      Command(TimeTag(TimeRelative),Stem,Args(String)),
-      Command(TimeTag(TimeComplete),Stem,Args(Number,Number,Number)),
-      Command(TimeTag(TimeRelative),Stem,Args(String))
-    ),
-    Metadata(MetaEntry(Key(String),Value(Object(Property(PropertyName(String),Boolean)))))
-  ),
-  Request(
-    TimeTag(TimeAbsolute),
-    RequestName(String),
-    Steps(
-      Command(TimeTag(TimeComplete),Stem,Args(Number,Number,Number),Metadata(MetaEntry(Key(String),Value(String))),Models(Model(Variable(String),Value(Number),Offset(String)))),
-      Command(TimeTag(TimeRelative),Stem,Args(String)),
-      Command(TimeTag(TimeComplete),Stem,Args(Number,Number,Number)),
-      Command(TimeTag(TimeRelative),Stem,Args(String)),
-      Command(TimeTag(TimeComplete),Stem,Args(Number,Number,Number)),
-      Command(TimeTag(TimeRelative),Stem,Args(String))
-    ),
-    Metadata(MetaEntry(Key(String),Value(String)))
-  )
-))
-`,
-  ],
 ];
 
 const errorTests = [
diff --git a/src/utilities/new-sequence-editor/sequencer-grammar-constants.ts b/src/utilities/new-sequence-editor/sequencer-grammar-constants.ts
index 73585ad684..77eff640d7 100644
--- a/src/utilities/new-sequence-editor/sequencer-grammar-constants.ts
+++ b/src/utilities/new-sequence-editor/sequencer-grammar-constants.ts
@@ -1,29 +1,3 @@
-import type { SyntaxNode } from '@lezer/common';
-
-export const TOKEN_ACTIVATE = 'Activate';
-export const TOKEN_GROUND_BLOCK = 'GroundBlock';
-export const TOKEN_GROUND_EVENT = 'GroundEvent';
-export const TOKEN_LOAD = 'Load';
 export const TOKEN_COMMAND = 'Command';
-export const TOKEN_REQUEST = 'Request';
 export const TOKEN_REPEAT_ARG = 'RepeatArg';
 export const TOKEN_ERROR = '⚠';
-
-export function getNameNode(stepNode: SyntaxNode | null) {
-  if (stepNode) {
-    switch (stepNode.name) {
-      case TOKEN_ACTIVATE:
-      case TOKEN_LOAD:
-        return stepNode.getChild('SequenceName');
-      case TOKEN_GROUND_BLOCK:
-      case TOKEN_GROUND_EVENT: {
-        return stepNode.getChild('GroundName');
-      }
-      case TOKEN_COMMAND: {
-        return stepNode.getChild('Stem');
-      }
-    }
-  }
-
-  return null;
-}
diff --git a/src/utilities/new-sequence-editor/to-seq-json.test.ts b/src/utilities/new-sequence-editor/to-seq-json.test.ts
index ee6d3b2bcd..61d3c626d3 100644
--- a/src/utilities/new-sequence-editor/to-seq-json.test.ts
+++ b/src/utilities/new-sequence-editor/to-seq-json.test.ts
@@ -10,7 +10,6 @@ import {
 import { readFileSync } from 'fs';
 import { describe, expect, it } from 'vitest';
 import { SeqLanguage } from '../codemirror';
-import { seqJsonToSequence } from './from-seq-json';
 import { sequenceToSeqJson } from './to-seq-json';
 
 function argArrToMap(cmdArgs: FswCommandArgument[]): FswCommandArgumentMap {
@@ -340,149 +339,7 @@ C ECHO L01STR
     expect(actual).toEqual(expectedJson);
   });
 
-  it('should generate loads, activates, ground blocks', () => {
-    const id = 'test.sequence';
-    const seq = `@ID "${id}"
-A2024-123T12:34:56 @ACTIVATE("activate.name") # No Args
-@ENGINE 10
-@EPOCH "epoch string"
-
-A2024-123T12:34:56 @GROUND_BLOCK("ground_block.name") # No Args
-
-A2024-123T12:34:56 @LOAD("load.name") # No Args
-@ENGINE 22
-@EPOCH "load epoch string"
-
-R123T12:34:56 @LOAD("load2.name") "foobar" 1 2
-@ENGINE 5
-
-R123T11:55:33 @GROUND_EVENT("ground_event.name") "foo" 1 2 3
-
-R123T12:34:56 @ACTIVATE("act2.name") "foo" 1 2 3  # Comment text
-@ENGINE -1
-    `;
-    const actual = sequenceToSeqJson(SeqLanguage.parser.parse(seq), seq, commandBanana, [], null, '');
-    const expectedJson = {
-      id,
-      metadata: {},
-      steps: [
-        {
-          args: [],
-          description: 'No Args',
-          engine: 10,
-          epoch: 'epoch string',
-          sequence: 'activate.name',
-          time: {
-            tag: '2024-123T12:34:56',
-            type: 'ABSOLUTE',
-          },
-          type: 'activate',
-        },
-        {
-          args: [],
-          description: 'No Args',
-          name: 'ground_block.name',
-          time: {
-            tag: '2024-123T12:34:56',
-            type: 'ABSOLUTE',
-          },
-          type: 'ground_block',
-        },
-        {
-          args: [],
-          description: 'No Args',
-          engine: 22,
-          epoch: 'load epoch string',
-          sequence: 'load.name',
-          time: {
-            tag: '2024-123T12:34:56',
-            type: 'ABSOLUTE',
-          },
-          type: 'load',
-        },
-        {
-          args: [
-            {
-              type: 'string',
-              value: 'foobar',
-            },
-            {
-              type: 'number',
-              value: 1,
-            },
-            {
-              type: 'number',
-              value: 2,
-            },
-          ],
-          engine: 5,
-          sequence: 'load2.name',
-          time: {
-            tag: '123T12:34:56',
-            type: 'COMMAND_RELATIVE',
-          },
-          type: 'load',
-        },
-        {
-          args: [
-            {
-              type: 'string',
-              value: 'foo',
-            },
-            {
-              type: 'number',
-              value: 1,
-            },
-            {
-              type: 'number',
-              value: 2,
-            },
-            {
-              type: 'number',
-              value: 3,
-            },
-          ],
-          name: 'ground_event.name',
-          time: {
-            tag: '123T11:55:33',
-            type: 'COMMAND_RELATIVE',
-          },
-          type: 'ground_event',
-        },
-        {
-          args: [
-            {
-              type: 'string',
-              value: 'foo',
-            },
-            {
-              type: 'number',
-              value: 1,
-            },
-            {
-              type: 'number',
-              value: 2,
-            },
-            {
-              type: 'number',
-              value: 3,
-            },
-          ],
-          description: 'Comment text',
-          engine: -1,
-          sequence: 'act2.name',
-          time: {
-            tag: '123T12:34:56',
-            type: 'COMMAND_RELATIVE',
-          },
-          type: 'activate',
-        },
-      ],
-    };
-    expect(actual).toEqual(expectedJson);
-  });
-
-  it('should allow any header ordering', () => {
+  it('header ordering', () => {
     function allPermutations(inputArr: string[]) {
       const result: string[][] = [];
       function permute(arr: string[], m: string[] = []) {
@@ -544,353 +401,91 @@ R123T12:34:56 @ACTIVATE("act2.name") "foo" 1 2 3  # Comment text
     });
   });
 
-  it('should serialize a request with nested metadata', () => {
-    const input = `
-A2024-123T12:34:56 @REQUEST_BEGIN("request.name") # Description Text
-  C CMD_0 1 2 3
-  @METADATA "foo" "bar"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
+  it('Convert quoted strings', () => {
+    const seq = `@ID "escaped_quotes"
 
-@REQUEST_END
-@METADATA "sub_object" {
-  "boolean": true
-}
-    `;
-    const actual = sequenceToSeqJson(SeqLanguage.parser.parse(input), input, commandBanana, [], null, 'id');
+    R1 ECHO "Can this handle \\"Escaped\\" quotes??" # and this "too"`;
+    const id = 'escaped_quotes';
+    const actual = sequenceToSeqJson(SeqLanguage.parser.parse(seq), seq, commandBanana, [], null, id);
     const expected = {
-      id: 'id',
+      id,
       metadata: {},
-      requests: [
+      steps: [
         {
-          description: 'Description Text',
-          metadata: {
-            sub_object: {
-              boolean: true,
-            },
-          },
-          name: 'request.name',
-          steps: [
-            {
-              args: [
-                {
-                  type: 'number',
-                  value: 1,
-                },
-                {
-                  type: 'number',
-                  value: 2,
-                },
-                {
-                  type: 'number',
-                  value: 3,
-                },
-              ],
-              metadata: { foo: 'bar' },
-              models: [{ offset: '00:00:00', value: 1, variable: 'a' }],
-              stem: 'CMD_0',
-              time: {
-                type: 'COMMAND_COMPLETE',
-              },
-              type: 'command',
-            },
-
+          args: [
             {
-              args: [
-                {
-                  type: 'string',
-                  value: '1 2 3',
-                },
-              ],
-              stem: 'CMD_1',
-              time: {
-                tag: '00:01:40',
-                type: 'COMMAND_RELATIVE',
-              },
-              type: 'command',
+              name: 'echo_string',
+              type: 'string',
+              value: `Can this handle "Escaped" quotes??`,
             },
           ],
-          time: {
-            tag: '2024-123T12:34:56',
-            type: 'ABSOLUTE',
-          },
-          type: 'request',
+          description: `and this "too"`,
+          stem: 'ECHO',
+          time: { tag: '00:00:01', type: 'COMMAND_RELATIVE' },
+          type: 'command',
         },
       ],
     };
     expect(actual).toEqual(expected);
   });
 
-  it('should serialize a request with simple metadata', () => {
-    const input = `
-@GROUND_EPOCH("GroundEpochName","+3:00") @REQUEST_BEGIN("request2.name")
-  C CMD_0 1 2 3
-  @METADATA "cmd_0_meta_name_0" "cmd_0_meta_value_0"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
-
-@REQUEST_END
-@METADATA "req_0_meta_name" "req_0_meta_value"
-    `;
-    const actual = sequenceToSeqJson(SeqLanguage.parser.parse(input), input, commandBanana, [], null, 'id');
+  it('Convert quoted metadata and models', () => {
+    const seq = `@ID "escaped_metadata"
+
+R00:00:01 ECHO "Can this handle \\"Escaped\\" quotes??" # and this "too"
+@METADATA "key" "value"
+@METADATA "home" " \\"world\\""
+@METADATA "array" [ "\\" quoted ", 1, true, null, "seq" ]
+@METADATA "object" { "\\"earth\\"" : "green", "array" : [ "\\" quoted ", 1, true, null, "seq" ]}
+@METADATA "this_\\"is\\"_my_key" "This is the value"
+@MODEL "Variable" 0 "Offset"
+@MODEL "Variable \\"Escaped\\"" 0 "Offset \\" \\" \\"\\""`;
+    const id = 'escaped_metadata';
+    const actual = sequenceToSeqJson(SeqLanguage.parser.parse(seq), seq, commandBanana, [], null, id);
     const expected = {
-      id: 'id',
+      id,
       metadata: {},
-      requests: [
+      steps: [
         {
-          ground_epoch: {
-            delta: '+3:00',
-            name: 'GroundEpochName',
-          },
-          metadata: {
-            req_0_meta_name: 'req_0_meta_value',
-          },
-          name: 'request2.name',
-          steps: [
-            {
-              args: [
-                {
-                  type: 'number',
-                  value: 1,
-                },
-                {
-                  type: 'number',
-                  value: 2,
-                },
-                {
-                  type: 'number',
-                  value: 3,
-                },
-              ],
-              metadata: {
-                cmd_0_meta_name_0: 'cmd_0_meta_value_0',
-              },
-              models: [{ offset: '00:00:00', value: 1, variable: 'a' }],
-              stem: 'CMD_0',
-              time: {
-                type: 'COMMAND_COMPLETE',
-              },
-              type: 'command',
-            },
-
+          args: [
             {
-              args: [
-                {
-                  type: 'string',
-                  value: '1 2 3',
-                },
-              ],
-              stem: 'CMD_1',
-              time: {
-                tag: '00:01:40',
-                type: 'COMMAND_RELATIVE',
-              },
-              type: 'command',
+              name: 'echo_string',
+              type: 'string',
+              value: 'Can this handle "Escaped" quotes??',
             },
           ],
-          type: 'request',
-        },
-      ],
-    };
-    expect(actual).toEqual(expected);
-  });
-
-  it('should serialize multiple requests', () => {
-    const input = `
-A2024-123T12:34:56 @REQUEST_BEGIN("request.name") # Description Text
-  C CMD_0 1 2 3
-  @METADATA "foo" "bar"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
-
-@REQUEST_END
-@METADATA "sub_object" {
-  "boolean": true
-}
-
-@GROUND_EPOCH("GroundEpochName","+3:00") @REQUEST_BEGIN("request2.name")
-  C CMD_0 1 2 3
-  @METADATA "foo" "bar"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
-
-@REQUEST_END
-@METADATA "foo" "bar"
-
-`;
-
-    const actual = sequenceToSeqJson(SeqLanguage.parser.parse(input), input, commandBanana, [], null, 'id');
-    const expected = {
-      id: 'id',
-      metadata: {},
-      requests: [
-        {
-          description: 'Description Text',
+          description: 'and this "too"',
           metadata: {
-            sub_object: {
-              boolean: true,
-            },
+            array: ['" quoted ', 1, true, null, 'seq'],
+            home: ' "world"',
+            key: 'value',
+            object: {
+              '"earth"': 'green',
+              array: ['" quoted ', 1, true, null, 'seq'],
+            },
+            'this_"is"_my_key': 'This is the value',
           },
-          name: 'request.name',
-          steps: [
+          models: [
             {
-              args: [
-                {
-                  type: 'number',
-                  value: 1,
-                },
-                {
-                  type: 'number',
-                  value: 2,
-                },
-                {
-                  type: 'number',
-                  value: 3,
-                },
-              ],
-              metadata: { foo: 'bar' },
-              models: [{ offset: '00:00:00', value: 1, variable: 'a' }],
-              stem: 'CMD_0',
-              time: {
-                type: 'COMMAND_COMPLETE',
-              },
-              type: 'command',
+              offset: 'Offset',
+              value: 0,
+              variable: 'Variable',
             },
-
             {
-              args: [
-                {
-                  type: 'string',
-                  value: '1 2 3',
-                },
-              ],
-              stem: 'CMD_1',
-              time: {
-                tag: '00:01:40',
-                type: 'COMMAND_RELATIVE',
-              },
-              type: 'command',
+              offset: 'Offset " " ""',
+              value: 0,
+              variable: 'Variable "Escaped"',
             },
           ],
+          stem: 'ECHO',
           time: {
-            tag: '2024-123T12:34:56',
-            type: 'ABSOLUTE',
-          },
-          type: 'request',
-        },
-
-        {
-          ground_epoch: {
-            delta: '+3:00',
-            name: 'GroundEpochName',
-          },
-          metadata: {
-            foo: 'bar',
+            tag: '00:00:01',
+            type: 'COMMAND_RELATIVE',
           },
-          name: 'request2.name',
-          steps: [
-            {
-              args: [
-                {
-                  type: 'number',
-                  value: 1,
-                },
-                {
-                  type: 'number',
-                  value: 2,
-                },
-                {
-                  type: 'number',
-                  value: 3,
-                },
-              ],
-              metadata: { foo: 'bar' },
-              models: [{ offset: '00:00:00', value: 1, variable: 'a' }],
-              stem: 'CMD_0',
-              time: {
-                type: 'COMMAND_COMPLETE',
-              },
-              type: 'command',
-            },
-
-            {
-              args: [
-                {
-                  type: 'string',
-                  value: '1 2 3',
-                },
-              ],
-              stem: 'CMD_1',
-              time: {
-                tag: '00:01:40',
-                type: 'COMMAND_RELATIVE',
-              },
-              type: 'command',
-            },
-          ],
-          type: 'request',
+          type: 'command',
         },
       ],
     };
     expect(actual).toEqual(expected);
   });
-
-  describe('round trip', () => {
-    it('should round trip commands', () => {
-      const input = `
-  @ID "test.seq"
-
-  C FSW_CMD_1 1e3 2.34
-  # comment
-  C FSW_CMD_1 0.123 -2.34 # inline description`;
-
-      const seqJson1 = sequenceToSeqJson(SeqLanguage.parser.parse(input), input, commandDictionary, [], null, 'id');
-      const seqN1 = seqJsonToSequence(seqJson1, [], null);
-      const seqJson2 = sequenceToSeqJson(SeqLanguage.parser.parse(seqN1), seqN1, commandDictionary, [], null, 'id');
-      expect(seqJson1).toEqual(seqJson2);
-    });
-
-    it('should round trip activates, loads, etc', () => {
-      const input = `
-@ID "test.seq"
-
-C FSW_CMD_1 1e3 2.34
-# comment
-C FSW_CMD_1 0.123 -2.34 # inline description
-
-A2024-123T12:34:56 @REQUEST_BEGIN("request.name") # Description Text
-  C CMD_0 1 2 3
-  @METADATA "foo" "bar"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
-
-@REQUEST_END
-@METADATA "sub_object" {
-  "boolean": true
-}
-
-@GROUND_EPOCH("GroundEpochName","+3:00") @REQUEST_BEGIN("request2.name")
-  C CMD_0 1 2 3
-  @METADATA "foo" "bar"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
-
-@REQUEST_END
-@METADATA "foo" "bar"
-  `;
-
-      const seqJson1 = sequenceToSeqJson(SeqLanguage.parser.parse(input), input, commandDictionary, [], null, 'id');
-      const seqN1 = seqJsonToSequence(seqJson1, [], null);
-      const seqJson2 = sequenceToSeqJson(SeqLanguage.parser.parse(seqN1), seqN1, commandDictionary, [], null, 'id');
-      // these should be deep copies
-      expect(seqJson1 === seqJson2).toBeFalsy();
-      expect(seqJson1).toEqual(seqJson2);
-    });
-  });
 });
diff --git a/src/utilities/new-sequence-editor/to-seq-json.ts b/src/utilities/new-sequence-editor/to-seq-json.ts
index 078bc784ab..ad624edd07 100644
--- a/src/utilities/new-sequence-editor/to-seq-json.ts
+++ b/src/utilities/new-sequence-editor/to-seq-json.ts
@@ -7,24 +7,17 @@ import type {
   ParameterDictionary,
 } from '@nasa-jpl/aerie-ampcs';
 import type {
-  Activate,
   Args,
   BooleanArgument,
   Command,
-  GroundBlock,
-  GroundEpoch,
-  GroundEvent,
   HardwareCommand,
   HexArgument,
   ImmediateCommand,
-  Load,
   Metadata,
   Model,
   NumberArgument,
   RepeatArgument,
-  Request,
   SeqJson,
-  Step,
   StringArgument,
   SymbolArgument,
   Time,
@@ -70,19 +63,11 @@ export function sequenceToSeqJson(
   if (seqJson.parameters) {
     variableList.push(...seqJson.parameters.map(value => value.name));
   }
-
-  let child = baseNode.getChild('Commands')?.firstChild;
-  seqJson.steps = [];
-  while (child) {
-    const step = parseStep(child, text, commandDictionary);
-    if (step) {
-      seqJson.steps.push(step);
-    }
-    child = child?.nextSibling;
-  }
-  if (!seqJson.steps.length) {
-    seqJson.steps = undefined;
-  }
+  seqJson.steps =
+    baseNode
+      .getChild('Commands')
+      ?.getChildren('Command')
+      .map(command => parseCommand(command, text, commandDictionary)) ?? undefined;
   seqJson.immediate_commands =
     baseNode
       .getChild('ImmediateCommands')
@@ -93,35 +78,10 @@ export function sequenceToSeqJson(
       .getChild('HardwareCommands')
       ?.getChildren('Command')
       .map(command => parseHardwareCommand(command, text)) ?? undefined;
-
-  seqJson.requests = baseNode
-    .getChild('Commands')
-    ?.getChildren('Request')
-    .map(requestNode => parseRequest(requestNode, text, commandDictionary));
-  if (seqJson.requests?.length === 0) {
-    seqJson.requests = undefined;
-  }
-
   customizeSeqJson(seqJson, parameterDictionaries, channelDictionary);
   return seqJson;
 }
 
-function parseStep(child: SyntaxNode, text: string, commandDictionary: CommandDictionary | null): Step | null {
-  switch (child.name) {
-    case 'Command':
-      return parseCommand(child, text, commandDictionary);
-    case 'Activate':
-    case 'Load':
-      return parseActivateLoad(child, text);
-    case 'GroundBlock':
-    case 'GroundEvent':
-      return parseGroundBlockEvent(child, text);
-  }
-  // SeqN allows comments that don't map to Seq.JSON
-  // Requests are also here in the tree
-  return null;
-}
-
 function parseLGO(node: SyntaxNode): Metadata | undefined {
   const lgoNode = node.getChild('Commands')?.getChild('LoadAndGoDirective');
   if (!lgoNode) {
@@ -179,7 +139,7 @@ function parseArg(
   }
 }
 
-function parseRepeatArgs(
+export function parseRepeatArgs(
   repeatArgsNode: SyntaxNode,
   text: string,
   dictRepeatArgument: FswCommandArgumentRepeat | null,
@@ -218,7 +178,7 @@ function parseRepeatArgs(
   return repeatArg;
 }
 
-function parseArgs(
+export function parseArgs(
   argsNode: SyntaxNode,
   text: string,
   commandDictionary: CommandDictionary | null,
@@ -253,15 +213,6 @@ function parseArgs(
   return args;
 }
 
-function parseGroundEpoch(groundEpochNode: SyntaxNode, text: string): GroundEpoch {
-  const deltaNode = groundEpochNode.getChild('Delta');
-  const nameNode = groundEpochNode.getChild('Name');
-  return {
-    delta: deltaNode ? unquoteUnescape(text.slice(deltaNode.from, deltaNode.to)) : '',
-    name: nameNode ? unquoteUnescape(text.slice(nameNode.from, nameNode.to)) : '',
-  };
-}
-
 /**
  *
  * @param commandNode
@@ -273,7 +224,7 @@ function parseGroundEpoch(groundEpochNode: SyntaxNode, text: string): GroundEpoc
  * Parses a time tag node and returns a Seq JSON time.
  * Defaults to an unknown absolute time if a command does not have a valid time tag.
  */
-function parseTime(commandNode: SyntaxNode, text: string): Time {
+export function parseTime(commandNode: SyntaxNode, text: string): Time {
   const timeTagNode = commandNode.getChild('TimeTag');
   let tag = 'UNKNOWN';
 
@@ -305,7 +256,7 @@ function parseTime(commandNode: SyntaxNode, text: string): Time {
       const { isNegative, days, hours, minutes, seconds, milliseconds } = getDurationTimeComponents(
         parseDurationString(timeTagEpochText, 'seconds'),
       );
-      tag = `${isNegative}${days}${days ? 'T' : ''}${hours}:${minutes}:${seconds}${milliseconds}`;
+      tag = `${isNegative}${days}${hours}:${minutes}:${seconds}${milliseconds}`;
       return { tag, type: 'EPOCH_RELATIVE' };
     }
 
@@ -325,7 +276,7 @@ function parseTime(commandNode: SyntaxNode, text: string): Time {
       const { isNegative, days, hours, minutes, seconds, milliseconds } = getDurationTimeComponents(
         parseDurationString(timeTagRelativeText, 'seconds'),
       );
-      tag = `${isNegative}${days}${days ? 'T' : ''}${hours}:${minutes}:${seconds}${milliseconds}`;
+      tag = `${isNegative}${days}${hours}:${minutes}:${seconds}${milliseconds}`;
       return { tag, type: 'COMMAND_RELATIVE' };
     }
 
@@ -408,24 +359,26 @@ function parseModel(node: SyntaxNode, text: string): Model[] | undefined {
     const valueNode = modelNode.getChild('Value');
     const offsetNode = modelNode.getChild('Offset');
 
-    const variable = variableNode ? unquoteUnescape(text.slice(variableNode.from, variableNode.to)) : 'UNKNOWN';
+    const variable = variableNode
+      ? (unquoteUnescape(text.slice(variableNode.from, variableNode.to)) as string)
+      : 'UNKNOWN';
 
     // Value can be string, number or boolean
     let value: Model['value'] = 0;
-
-    const valueChild = valueNode?.firstChild;
-    if (valueChild) {
-      const valueText = text.slice(valueChild.from, valueChild.to);
-      if (valueChild.name === 'String') {
-        value = unquoteUnescape(valueText);
-      } else if (valueChild.name === 'Boolean') {
-        value = !/^FALSE$/i.test(valueText);
-      } else if (valueChild.name === 'Number') {
-        value = Number(valueText);
+    if (valueNode) {
+      const valueChild = valueNode.firstChild;
+      if (valueChild) {
+        const valueText = text.slice(valueChild.from, valueChild.to);
+        if (valueChild.name === 'String') {
+          value = unquoteUnescape(valueText);
+        } else if (valueChild.name === 'Boolean') {
+          value = !/^FALSE$/i.test(valueText);
+        } else if (valueChild.name === 'Number') {
+          value = Number(valueText);
+        }
       }
     }
-
-    const offset = offsetNode ? unquoteUnescape(text.slice(offsetNode.from, offsetNode.to)) : 'UNKNOWN';
+    const offset = offsetNode ? (unquoteUnescape(text.slice(offsetNode.from, offsetNode.to)) as string) : 'UNKNOWN';
 
     models.push({ offset, value, variable });
   }
@@ -438,126 +391,15 @@ function parseDescription(node: SyntaxNode, text: string): string | undefined {
   if (!descriptionNode) {
     return undefined;
   }
-  // +1 offset to drop '#' prefix
   const description = text.slice(descriptionNode.from + 1, descriptionNode.to).trim();
-  return removeEscapedQuotes(description);
-}
-
-function parseRequest(requestNode: SyntaxNode, text: string, commandDictionary: CommandDictionary | null): Request {
-  let ground_epoch = undefined;
-  let time = undefined;
-  const groundEpochNode = requestNode.getChild('GroundEpoch');
-  if (groundEpochNode) {
-    ground_epoch = parseGroundEpoch(groundEpochNode, text);
-  } else {
-    time = parseTime(requestNode, text);
-  }
-  const nameNode = requestNode.getChild('RequestName');
-  const name = nameNode ? unquoteUnescape(text.slice(nameNode.from, nameNode.to)) : 'UNKNOWN';
-  const description = parseDescription(requestNode, text);
-  const metadata = parseMetadata(requestNode, text);
-
-  const steps: Step[] = [];
-  const stepsNode = requestNode.getChild('Steps');
-  if (stepsNode) {
-    let stepNode = stepsNode.firstChild;
-    while (stepNode) {
-      const step = parseStep(stepNode, text, commandDictionary);
-      if (step) {
-        steps.push(step);
-      }
-      stepNode = stepNode?.nextSibling;
-    }
-  }
-
-  if (steps.length === 0) {
-    // request with empty steps is disallowed in seq.json
-    steps.push({
-      args: [],
-      stem: 'UNKNOWN',
-      time: { tag: 'UNKNOWN', type: 'ABSOLUTE' },
-      type: 'command',
-    });
-  }
-
-  // ground epoch
-  return {
-    ground_epoch,
-    name,
-    steps: steps as [Step, ...Step[]],
-    time,
-    type: 'request',
-    ...{ description },
-    ...{ metadata },
-  };
+  return removeEscapedQuotes(description) as string;
 }
 
-function parseGroundBlockEvent(stepNode: SyntaxNode, text: string): GroundBlock | GroundEvent {
-  const time = parseTime(stepNode, text);
-
-  const nameNode = stepNode.getChild('GroundName');
-  const name = nameNode ? unquoteUnescape(text.slice(nameNode.from, nameNode.to)) : 'UNKNOWN';
-
-  const argsNode = stepNode.getChild('Args');
-  // step not in dictionary, so not passing command dict
-  const args = argsNode ? parseArgs(argsNode, text, null, name) : [];
-
-  const description = parseDescription(stepNode, text);
-  const metadata = parseMetadata(stepNode, text);
-  const models = parseModel(stepNode, text);
-
-  return {
-    args,
-    name,
-    time,
-    type: stepNode.name === 'GroundBlock' ? 'ground_block' : 'ground_event',
-    ...{ description },
-    ...{ models },
-    ...{ metadata },
-  };
-}
-
-function parseActivateLoad(stepNode: SyntaxNode, text: string): Activate | Load {
-  const time = parseTime(stepNode, text);
-
-  const nameNode = stepNode.getChild('SequenceName');
-  const sequence = nameNode ? unquoteUnescape(text.slice(nameNode.from, nameNode.to)) : 'UNKNOWN';
-
-  const argsNode = stepNode.getChild('Args');
-  // step not in dictionary, so not passing command dict
-  const args = argsNode ? parseArgs(argsNode, text, null, sequence) : [];
-
-  const engine = parseEngine(stepNode, text);
-  const epoch = parseEpoch(stepNode, text);
-
-  const description = parseDescription(stepNode, text);
-  const metadata = parseMetadata(stepNode, text);
-  const models = parseModel(stepNode, text);
-
-  return {
-    args,
-    engine,
-    epoch,
-    sequence,
-    time,
-    type: stepNode.name === 'Load' ? 'load' : 'activate',
-    ...{ description },
-    ...{ models },
-    ...{ metadata },
-  };
-}
-
-function parseEngine(stepNode: SyntaxNode, text: string): number | undefined {
-  const engineNode = stepNode.getChild('Engine')?.getChild('Number');
-  return engineNode ? parseInt(text.slice(engineNode.from, engineNode.to), 10) : undefined;
-}
-
-function parseEpoch(stepNode: SyntaxNode, text: string): string | undefined {
-  const epochNode = stepNode.getChild('Epoch')?.getChild('String');
-  return epochNode ? unquoteUnescape(text.slice(epochNode.from, epochNode.to)) : undefined;
-}
-
-function parseCommand(commandNode: SyntaxNode, text: string, commandDictionary: CommandDictionary | null): Command {
+export function parseCommand(
+  commandNode: SyntaxNode,
+  text: string,
+  commandDictionary: CommandDictionary | null,
+): Command {
   const time = parseTime(commandNode, text);
 
   const stemNode = commandNode.getChild('Stem');
@@ -575,13 +417,13 @@ function parseCommand(commandNode: SyntaxNode, text: string, commandDictionary:
     stem,
     time,
     type: 'command',
-    ...{ description },
-    ...{ models },
-    ...{ metadata },
+    ...(description ? { description } : {}),
+    ...(models ? { models } : {}),
+    ...(metadata ? { metadata } : {}),
   };
 }
 
-function parseImmediateCommand(
+export function parseImmediateCommand(
   commandNode: SyntaxNode,
   text: string,
   commandDictionary: CommandDictionary | null,
@@ -603,7 +445,7 @@ function parseImmediateCommand(
   };
 }
 
-function parseHardwareCommand(commandNode: SyntaxNode, text: string): HardwareCommand {
+export function parseHardwareCommand(commandNode: SyntaxNode, text: string): HardwareCommand {
   const stemNode = commandNode.getChild('Stem');
   const stem = stemNode ? text.slice(stemNode.from, stemNode.to) : 'UNKNOWN';
   const description = parseDescription(commandNode, text);
@@ -654,7 +496,7 @@ function parseMetadata(node: SyntaxNode, text: string): Metadata | undefined {
       return; // Skip this entry if either the key or value is missing
     }
 
-    const keyText = unquoteUnescape(text.slice(keyNode.from, keyNode.to));
+    const keyText = unquoteUnescape(text.slice(keyNode.from, keyNode.to)) as string;
 
     let value = text.slice(valueNode.from, valueNode.to);
     try {
diff --git a/src/utilities/new-sequence-editor/token.test.ts b/src/utilities/new-sequence-editor/token.test.ts
index 8c995b61a5..531056f62b 100644
--- a/src/utilities/new-sequence-editor/token.test.ts
+++ b/src/utilities/new-sequence-editor/token.test.ts
@@ -1,10 +1,11 @@
 /* eslint-disable no-undef */
 
 import type { SyntaxNode, Tree } from '@lezer/common';
+import assert from 'assert';
 import { readFileSync, readdirSync } from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
-import { assert, describe, it } from 'vitest';
+import { describe, it } from 'vitest';
 import { SeqLanguage } from '../codemirror';
 
 const ERROR = '⚠';
@@ -17,10 +18,6 @@ const METADATA_ENTRY_TOKEN = 'MetaEntry';
 const ID_DECLARATION = 'IdDeclaration';
 const PARAMETER_DECLARATION = 'ParameterDeclaration';
 const LOCAL_DECLARATION = 'LocalDeclaration';
-const ACTIVATE_NODE = 'Activate';
-const LOAD_NODE = 'Load';
-const GROUND_BLOCK_NODE = 'GroundBlock';
-const GROUND_EVENT_NODE = 'GroundEvent';
 
 function getMetaType(node: SyntaxNode) {
   return node?.firstChild?.nextSibling?.firstChild?.name;
@@ -31,10 +28,6 @@ function getMetaValue(node: SyntaxNode, input: string) {
   return JSON.parse(input.slice(mv!.from, mv!.to));
 }
 
-function getNodeText(node: SyntaxNode, input: string) {
-  return input.slice(node.from, node.to);
-}
-
 describe('metadata', () => {
   it('primitive types', () => {
     const input = `
@@ -110,6 +103,10 @@ describe('header directives', () => {
     return null;
   }
 
+  function getNodeText(node: SyntaxNode, input: string) {
+    return input.slice(node.from, node.to);
+  }
+
   function allPermutations(inputArr: string[]) {
     const result: string[][] = [];
     function permute(arr: string[], m: string[] = []) {
@@ -191,110 +188,6 @@ describe('header directives', () => {
   });
 });
 
-describe('seqgen directives', () => {
-  it('activates', () => {
-    const input = `
-A2024-123T12:34:56 @ACTIVATE("activate.name") # No Args
-@ENGINE 10
-@EPOCH "epoch string"
-R123T12:34:56 @ACTIVATE("act2.name") "foo" 1 2 3  # Comment text
-@ENGINE -1
-  `;
-    assertNoErrorNodes(input);
-    const parseTree = SeqLanguage.parser.parse(input);
-    const activates = parseTree.topNode.firstChild?.getChildren(ACTIVATE_NODE);
-    assert.equal(activates?.length, 2);
-  });
-
-  it('loads', () => {
-    const input = `
-  A2024-123T12:34:56 @LOAD("load.name") # No Args
-  @ENGINE 10
-  @EPOCH "epoch string"
-  R123T12:34:56 @LOAD("load2.name") "foo" 1 2 3  # No Args
-  @ENGINE -1
-    `;
-    assertNoErrorNodes(input);
-    const parseTree = SeqLanguage.parser.parse(input);
-    const activates = parseTree.topNode.firstChild?.getChildren(LOAD_NODE);
-    assert.equal(activates?.length, 2);
-  });
-
-  it('ground', () => {
-    const input = `
-A2024-123T12:34:56 @GROUND_BLOCK("ground_block.name") # No Args
-R123T12:34:56 @GROUND_EVENT("ground_event.name") "foo" 1 2 3  # No Args
-  `;
-    assertNoErrorNodes(input);
-    const parseTree = SeqLanguage.parser.parse(input);
-    assert.isNotNull(parseTree.topNode.firstChild);
-    const groundBlocks = parseTree.topNode.firstChild!.getChildren(GROUND_BLOCK_NODE);
-    assert.equal(groundBlocks.length, 1);
-    assert.equal(getNodeText(groundBlocks[0].getChild('GroundName')!, input), '"ground_block.name"');
-    const groundEvents = parseTree.topNode.firstChild!.getChildren(GROUND_EVENT_NODE);
-    assert.equal(groundEvents.length, 1);
-    assert.equal(getNodeText(groundEvents[0].getChild('GroundName')!, input), '"ground_event.name"');
-  });
-
-  it('request', () => {
-    const input = `@GROUND_EPOCH("Name","+3:00") @REQUEST_BEGIN("request.name") # Description Text
-  C CMD_0 1 2 3
-  @METADATA "foo" "bar"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
-
-  C CMD_2 1 2 3
-
-  R100 CMD_3 "1 2 3"
-
-@REQUEST_END
-@METADATA "sub_object" {
-  "boolean": true
-}
-
-
-A2024-123T12:34:56 @REQUEST_BEGIN("request2.name")
-  C CMD_0 1 2 3
-  @METADATA "foo" "bar"
-  @MODEL "a" 1 "00:00:00"
-
-  R100 CMD_1 "1 2 3"
-
-  C CMD_2 1 2 3
-
-  R100 CMD_3 "1 2 3"
-
-  C CMD_4 1 2 3
-
-  R100 CMD_5 "1 2 3"
-
-@REQUEST_END
-@METADATA "foo" "bar"
-`;
-    assertNoErrorNodes(input);
-    const parseTree = SeqLanguage.parser.parse(input);
-    assert.isNotNull(parseTree.topNode.firstChild);
-    const requests = parseTree.topNode.firstChild!.getChildren('Request');
-    assert.equal(requests.length, 2);
-
-    assert.equal(getNodeText(requests[0].getChild('RequestName')!, input), '"request.name"');
-    assert.equal(getNodeText(requests[0].getChild('LineComment')!, input), '# Description Text');
-    const request0GrondEpoch = requests[0].getChild('GroundEpoch');
-    assert.equal(getNodeText(request0GrondEpoch!.getChild('Name')!, input), '"Name"');
-    assert.equal(getNodeText(request0GrondEpoch!.getChild('Delta')!, input), '"+3:00"');
-    assert.equal(requests[0].getChild('Steps')?.getChildren('Command').length, 4);
-    const request0Meta0 = requests[0].getChild('Metadata')!.getChild('MetaEntry')!;
-    assert.deepEqual(JSON.parse(getNodeText(request0Meta0.getChild('Value')!, input)), {
-      boolean: true,
-    });
-
-    assert.equal(getNodeText(requests[1].getChild('RequestName')!, input), '"request2.name"');
-    assert.equal(getNodeText(requests[1].getChild('TimeTag')!, input), 'A2024-123T12:34:56 ');
-    assert.equal(requests[1].getChild('Steps')?.getChildren('Command').length, 6);
-  });
-});
-
 describe('error positions', () => {
   for (const { testname, input, first_error } of [
     {
@@ -420,13 +313,10 @@ CMD0
   });
 });
 
-function assertNoErrorNodes(input: string, verbose?: boolean) {
+function assertNoErrorNodes(input: string) {
   const cursor = SeqLanguage.parser.parse(input).cursor();
   do {
     const { node } = cursor;
-    if (verbose) {
-      console.log(node.type.name);
-    }
     assert.notStrictEqual(node.type.name, ERROR);
   } while (cursor.next());
 }
diff --git a/src/utilities/new-sequence-editor/tree-utils.ts b/src/utilities/new-sequence-editor/tree-utils.ts
index 5bcd48da0c..bf0b90fe89 100644
--- a/src/utilities/new-sequence-editor/tree-utils.ts
+++ b/src/utilities/new-sequence-editor/tree-utils.ts
@@ -46,10 +46,9 @@ export function getFromAndTo(nodes: (SyntaxNode | null)[]): { from: number; to:
   );
 }
 
-export function getAncestorNode(node: SyntaxNode | null, ...names: string[]) {
+export function getAncestorNode(node: SyntaxNode | null, name: string) {
   let ancestorNode: SyntaxNode | null = node;
-
-  while (ancestorNode && !names.includes(ancestorNode.name)) {
+  while (ancestorNode && ancestorNode.name !== name) {
     ancestorNode = ancestorNode.parent;
   }
   return ancestorNode;