How to Migrate from Reasonix 0.x to 1.x: Complete Go Rewrite Guide

Reasonix 1.x requires installing the new Go-based binary and running the /migrate command to safely import your legacy TypeScript 0.x configuration, credentials, and sessions into the rewritten engine.

Reasonix 1.x represents a complete architectural overhaul of the original engine, migrating the entire codebase from TypeScript to Go. Because the binary format, configuration model, and storage mechanisms have fundamentally changed in esengine/DeepSeek-Reasonix, moving from the 0.x line to 1.x requires deliberate migration steps rather than a simple upgrade.

Understanding the Architecture Change

The 0.x series was built on Node.js and TypeScript, while Reasonix 1.x is a statically compiled Go binary. This rewrite changes how the engine stores configuration, manages API credentials, and persists session memory. The migration process is designed to be non-destructive and idempotent, ensuring your existing 0.x data remains untouched while creating references in the new 1.x format.

Installing Reasonix 1.x

You have three methods to obtain the 1.x binary, each shipping the compiled Go engine rather than JavaScript source.

Option 1: npm Installation (Recommended)

The simplest distribution method wraps the pre-built Go binary in an npm package:

npm i -g reasonix

This command pulls the current 1.x release and installs the platform-appropriate binary into your system path.

Option 2: Pre-built Binaries

Download platform-specific archives directly from the GitHub releases page. Choose the .tar.gz for macOS/Linux or .zip for Windows:

# Example for Linux/macOS

curl -L https://github.com/esengine/DeepSeek-Reasonix/releases/latest/download/reasonix-linux-amd64.tar.gz | tar xz

Option 3: Build from Source

Clone the repository and compile using the provided Makefile:

git clone https://github.com/esengine/DeepSeek-Reasonix.git
cd DeepSeek-Reasonix
make build

This produces ./bin/reasonix (or reasonix.exe on Windows) from the Go source in the repository.

Migrating Configuration Files

Legacy 0.x installations used config.toml or config.json stored in OS-specific locations such as ~/Library/Application Support/reasonix/ (macOS), ~/.config/reasonix/ (Linux), or ~/.reasonix/.

Reasonix 1.x expects a reasonix.toml file located in the user’s Reasonix home directory:

• macOS/Linux: ~/.reasonix/
• Windows: %AppData%\reasonix\

On first launch, the 1.x binary automatically scans for existing 0.x configuration files in the legacy paths and imports the settings. If you launched the CLI before the legacy files were present, or if the automatic import missed values, execute the built-in migration command:

reasonix
/migrate

The /migrate command checks for legacy configs, credentials, and session directories, then reports a summary of imported items.

Handling Credentials and Environment Variables

Provider credentials and API keys are no longer stored in the main configuration file. Reasonix 1.x maintains a .env file within the Reasonix home directory (~/.reasonix/.env or %AppData%\reasonix\.env).

The migration process copies any keys found in your 0.x configuration (such as DEEPSEEK_API_KEY or MIMO_API_KEY) into this new .env file while preserving the original environment variable names. This separation keeps sensitive credentials out of version-controlled configuration files.

Migrating Sessions and Memory

Session migration occurs on a per-workspace basis. The 1.x engine imports legacy sessions while retaining their original titles and placing them into the corresponding workspace directories under the new REASONIX.md-driven memory system.

This import is non-destructive: the original session files remain untouched in their 0.x locations, and the Go engine only adds references to the imported sessions. The new memory system uses REASONIX.md files as the central instruction and fact store, replacing the previous JSON-based storage.

Running the Migration Command

After installing the 1.x binary, start an interactive session:

reasonix

Inside the prompt, run the migration utility:

/migrate

If your 0.x data lives in a custom location (for example, a specific Windows install directory), specify the source path:

/migrate --from "D:\OldReasonix"

The command prints progress updates and validates the import of configurations, credentials, and session archives.

Post-Migration Verification

Confirm successful migration by checking your new configuration structure and testing memory access:

# Verify configuration

cat ~/.reasonix/reasonix.toml

# Verify credentials

cat ~/.reasonix/.env

# Test memory commands

/memory
/memory recall
/memory revisions <fact-id>

Ensure that reasonix.toml reflects your imported settings and that the .env file contains the necessary API keys. The migration is intentionally safe: it never overwrites an existing reasonix.toml or .env file, respecting markers that indicate prior imports to make the process idempotent.

Summary

• Reasonix 1.x is a complete Go rewrite that requires explicit migration from the TypeScript 0.x line.
• Install via npm i -g reasonix, GitHub releases, or make build from the esengine/DeepSeek-Reasonix repository.
• Run /migrate inside the 1.x CLI to import legacy config.toml/config.json files from standard OS paths.
• Credentials migrate to a dedicated .env file in the Reasonix home directory.
• Sessions import non-destructively into the REASONIX.md-based memory system.
• The migration process is idempotent and will not overwrite existing 1.x configuration files.

Frequently Asked Questions

Is the migration from Reasonix 0.x to 1.x destructive?

No. The migration process only reads from your 0.x installation and creates new files in the 1.x format. Original configuration files, session data, and credentials in legacy locations remain untouched. The 1.x engine creates references to imported sessions rather than moving the underlying files.

Can I run Reasonix 1.x alongside 0.x?

Yes. Because 1.x uses entirely different binary names, configuration paths, and storage formats, both versions can coexist on the same system. The 1.x binary looks for legacy data only when explicitly running /migrate and otherwise operates independently from 0.x installations.

What happens if the automatic config import fails?

If the first-launch auto-import misses values or if you started 1.x before legacy files were present, manually trigger the migration with the /migrate command. You can also specify a custom source directory using the --from flag if your 0.x configuration resides in a non-standard location not covered by the automatic search paths documented in docs/CONFIG_PATHS.md.

Where are my migrated sessions stored in Reasonix 1.x?

Migrated sessions are placed into workspace directories under the new Reasonix home folder (~/.reasonix/ or %AppData%\reasonix\), integrated into the REASONIX.md-driven memory system. The original session files remain in their 0.x locations, while 1.x maintains references to them within its new memory architecture.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}