Dev Flow

Resume the same Codex or DeepSeek Harness task after an interruption, with its scope, stage, and remaining verification intact.

Install · Two-minute demo · Website

简体中文 · English · 繁體中文 · 日本語 · 한국어 · Español · Français · Deutsch · Português (Brasil)

Dev Flow keeps a long-running AI coding task's scope, current stage, remaining verification, and recovery state outside chat history. After context compaction or a Host restart, Codex or DeepSeek Harness reads the same local Task and continues the unfinished work instead of reconstructing progress from a partial conversation.

Shortest installation path

Current stable @latest artifacts support macOS arm64. Current source also implements Windows 10/11 desktop x64 and has native Windows 11 evidence; the stable claim expands only after an independent release and final Host journey. See the Support Matrix for exact Host, Node.js, source, and stable-package coverage.

npm install -g @imotong/dev-flow@latest
dev-flow

After installation, use the corresponding entry from a Git repository.

Codex can select Dev Flow automatically. To enter explicitly:

$dev-flow-codex:dev-flow Fix the failed-login attempt limit and run only targeted tests.

Every direct DeepSeek Harness user message that needs Dev Flow uses:

/dev-flow Fix the failed-login attempt limit and run only targeted tests.

Native Host commands are diagnostic and recovery entry points. See the Codex guide, DeepSeek guide, and Command Reference for installation, status, resume, and removal details.

Have you encountered this?

A code change is implemented and only one targeted test remains. Then the session is compacted or the Host restarts. The next session sees partial chat and the current repository, but cannot tell which steps are complete or whether old test results still apply. It rescans, repeats changes, or skips the remaining work.

Dev Flow stores that progress as a local Task. The next session reads the Task first and continues from its saved stage and next step.

Four things it manages

Action	What Dev Flow retains and checks
Remember	Original request, current stage, completed verification, blockers, and outcome
Limit	Task Plan file scope, one-write file authorization, automatic verification-command count, repeated test loops, and permission for full suites or manual handoff
Decide	Which old test and comprehension records became stale after implementation changes, and whether repository state still matches the Task
Recover	Whether an uncertain Action should continue, be recorded, block, or retry safely

Codex and DeepSeek still read code, edit files, and run commands. The packaged Codex hook uses its package-owned launcher, while DeepSeek uses its structured-file-tool entry; each sends target paths to Core before a write. An unplanned path enters BLOCKED so the developer can allow that exact write, revise the Task Plan, or reject it. Core also reconciles Task-introduced paths before testing and DONE.

Understand it in 30 seconds

Using an agent directly	What Dev Flow adds
Progress is reconstructed after an interrupted session	Resume the same local Task
A local task gradually expands in scope	Ask before supported unplanned writes and reconcile actual paths before delivery
Targeted testing keeps expanding	Retain the verification budget
The same check and failure keep repeating	Pause after the third exact repetition and wait for the developer
A missing operation response is retried immediately	Read the current Task and Recovery state first
Test results are mixed with later code changes	Retain the current stage and its corresponding evidence

Tasks that fit

Dev Flow fits real repository work that continues across sessions, days, or Host restarts, especially when a change needs explicit scope, targeted verification, a rework path, or a comprehension check before delivery. One primary repository plus a small number of explicit additional repositories is an advanced use case.

One-off questions, code explanations, status queries, and mechanical small edits that need no durable progress are usually simpler with Codex or DeepSeek directly. Dev Flow is also not a general task orchestrator, remote execution platform, or security sandbox.

Relationship to other tools

Tool	Responsibility
Codex / DeepSeek	Read repositories, change code, and run commands
OpenSpec / Spec Kit	Help organize requirements, design, and tasks
Dev Flow	Retain the current Task stage, scope, verification budget, recovery state, and legal next step

OpenSpec and Spec Kit are optional methods, not Dev Flow's primary position. There is no OpenSpec / Spec Kit artifact importer today; thinner integration remains a future direction.

Continue after an interruption

Before restart
Task: auth-rate-limit
State: TEST
Revision: 5
Completed: implementation
Remaining: targeted auth test

After restart
Task: auth-rate-limit
State: TEST
Revision: 5
Next: run the remaining targeted auth test

On resume, the Host reads the same Task's current stage, scope, remaining verification, and recovery state. It continues the remaining test instead of inferring progress from chat history. See the two-minute interruption story.

Stable support, current source, and boundaries

Product	Verified environment
dev-flow-codex	macOS arm64, Node.js >=24, Codex >=0.147.0
dev-flow-deepseek	macOS arm64, Node.js >=24, DSH >=0.1.0-rc.6
@imotong/dev-flow	macOS arm64, Node.js >=20

Current source additionally selects the exact win32-x64 package runtime for Windows 10/11 desktop x64. Windows Server, 32-bit Windows, and Windows ARM64 are not supported. The Windows default data directory is %LOCALAPPDATA%\dev-flow\data, and configuration is %USERPROFILE%\.dev-flow\config.json. This source capability has not changed the stable @latest table above.

Host packages select the platform implementation outside Core. macOS and Windows each own their local path, permission, process, signal, and executable rules, while Core Task and workflow semantics remain platform-neutral.

Dev Flow remains early and external adoption is limited. Current boundaries include:

• Core observes Git read-only and does not commit, push, merge, rebase, tag, or publish;
• file changes and command execution remain with user-authorized Codex or DeepSeek;
• the Host performs write-before checks only for the listed structured tools; Core does not intercept every file operation and is not a shell or file-system sandbox;
• writes made by Bash, external processes, or specialized tools may be found only by Core's Implementation/Delivery reconciliation;
• the WebUI is a local loopback single-user view and diagnostic entry, not a cloud project manager;
• stable support comes only from public artifacts and real Host journeys listed in the Support Matrix.

Detailed documentation

What you need	Start here
Product position, target users, and non-goals	Product
A real interruption-and-resume story	Demo
Stable, source-only, unverified, and current gaps	Project Status
Future priorities	Roadmap
Core, Adapter, Store, Recovery, and protocol	Architecture
Complete CLI, selector, and MCP reference	Command Reference
Local WebUI	WebUI
Supported platforms and Hosts	Support Matrix
Documentation and source responsibilities	Manifest
Security boundaries	Security · Threat Model
Contributing	Contributing

Local development

Repository development requires Go >=1.26, Node.js >=24, and pnpm >=11 <12:

pnpm install --frozen-lockfile
pnpm run validate

License

Apache License 2.0