@shenlee/devcrew 0.1.1 → 0.1.2

package/README.md

@@ -12,10 +12,10 @@ The first release is intentionally local-first. DevCrew stores workflow state an
 
 - Gated phases for requirements, architecture, implementation planning, and test reporting.
 - Two workflow modes: `feature` for existing repositories and `greenfield` for new products.
-- Safe execution modes: `plan` is the default; `apply` must be explicitly requested before implementer/tester roles can write files or run validation commands.
+- Safe execution modes: `plan` is the default; `apply` must be explicit. Implementation planning stays read-only, while implementation and testing run in a DevCrew-owned Git worktree.
 - Host-preferred backend selection: Codex runs default to Codex, Claude Code runs default to Claude.
 - Orchestrated role execution: `devcrew_start` runs the PM role, and `devcrew_continue` runs the next phase role before opening the gate.
-- Implementation review artifact: implementation gates include changed files, captured diff, and architecture compliance review notes.
+- Implementation review artifact: isolated execution records changed files, a binary-capable diff, lint evidence, and architecture compliance notes; testing refreshes the reviewed diff before promotion.
 - Repository artifacts in `.devcrew/runs/<run-id>/state.json` and `docs/devcrew/<run-id>/`.
 - Standards discovery from `.devcrew/standards.md`, `AGENTS.md`, `CLAUDE.md`, README, and common project manifests.
 - MCP tools: `devcrew_start`, `devcrew_status`, `devcrew_answer`, `devcrew_approve`, `devcrew_reject`, `devcrew_continue`, and `devcrew_artifact`.
@@ -34,7 +34,7 @@ Restart Codex, open the plugin directory, choose the DevCrew marketplace, and in
 The plugin starts the DevCrew MCP server with:
 
 ```bash
-npm exec --silent --yes --package=@shenlee/devcrew@0.1.1 -- node -e "<DevCrew CLI wrapper>" -- serve --stdio
+npm exec --silent --yes --package=@shenlee/devcrew@0.1.2 -- node -e "<DevCrew CLI wrapper>" -- serve --stdio
 ```
 
 The plugin locks the MCP server to the published npm package version, so users do not need to clone the source or build TypeScript at install time. You only need Node.js and network access the first time Codex starts the MCP server.
@@ -81,12 +81,26 @@ The agent should call `devcrew_start`, show the PM-generated requirements artifa
 
 Plugins set `DEVCREW_HOST` for host detection, so `devcrew_start` can omit `host` unless you want to override it. DevCrew records the latest run as the repository's active run, so follow-up MCP calls can omit `runId`.
 
-By default DevCrew runs in `plan` mode. To allow the implementer/tester phases to make repository changes and run configured verification commands, explicitly request apply mode:
+By default DevCrew runs in `plan` mode. To allow isolated execution to modify files and isolated testing to run configured verification commands, explicitly request apply mode:
 
 ```text
 Use DevCrew in apply mode to implement audit logging for the billing API.
 ```
 
+Apply mode follows this sequence:
+
+```text
+requirements approval
+-> architecture approval
+-> implementation plan approval
+-> isolated execution
+-> isolated testing
+-> testing approval
+-> patch promotion to requester repository
+```
+
+Apply requires a Git repository, a real Codex or Claude SDK backend, and a clean requester worktree when isolated execution starts and when the patch is promoted. After approving the implementation plan, call `devcrew_continue` once for isolated execution and again for isolated testing. The requester repository is unchanged until the testing gate is approved. Rejecting testing and answering the feedback returns the same isolated workspace to `execution` without changing the requester repository.
+
 DevCrew auto-discovers verification commands from common project manifests. The current rules prefer `package.json` scripts (`validate`, then `test`, then `typecheck`/`lint`), then fall back to `go test ./...`, `cargo test`, or `python -m pytest` when matching manifests are present.
 
 You can override discovery with explicit commands in `.devcrew/config.json`:
@@ -119,7 +133,7 @@ For published installs, the host SDK packages are pinned optional dependencies s
 
 Public npm publishing is handled by the `npm publish` GitHub Actions workflow. It runs validation, checks the package with `npm pack --dry-run`, and publishes with npm provenance when a GitHub Release is published or the workflow is manually dispatched with `NPM_TOKEN` configured.
 
-After publishing the npm version referenced by the Codex plugin, run the real marketplace smoke test:
+After publishing `@shenlee/devcrew@0.1.2`, run the real marketplace smoke test. This is a post-publication check because the plugin is version-locked to the npm package:
 
 ```bash
 npm run smoke:codex-plugin

package/README.zh-CN.md

@@ -12,10 +12,10 @@ DevCrew 是一个面向 Codex、Claude Code 等编程 Agent 的本地工作流
 
 - 内置阶段门禁：需求确认、架构确认、实现计划确认、测试报告确认。
 - 支持两种工作流：`feature` 用于已有项目功能开发，`greenfield` 用于从零开始的新产品。
-- 支持安全执行模式：默认是 `plan`，只有显式请求 `apply` 时，implementer/tester 阶段才允许写文件或运行验证命令。
+- 支持安全执行模式：默认是 `plan`，`apply` 必须显式开启。实现计划阶段始终只读，真正的实现和测试在 DevCrew 管理的 Git worktree 中隔离执行。
 - 默认按当前宿主选择后端：在 Codex 中优先使用 Codex，在 Claude Code 中优先使用 Claude。
 - 已接入角色编排：`devcrew_start` 会先运行 PM 角色，`devcrew_continue` 会运行下一阶段角色，然后再打开阶段门禁。
-- 实现评审产物：implementation gate 会附带 changed files、捕获的 diff 和架构符合性审查说明。
+- 实现评审产物：隔离执行会记录 changed files、支持二进制的 diff、lint 证据和架构符合性说明；测试结束后会重新生成评审 diff，再等待晋升。
 - 运行状态写入 `.devcrew/runs/<run-id>/state.json`，评审产物写入 `docs/devcrew/<run-id>/`。
 - 自动发现项目规范：`.devcrew/standards.md`、`AGENTS.md`、`CLAUDE.md`、README 以及常见项目配置文件。
 - 提供 MCP 工具：`devcrew_start`、`devcrew_status`、`devcrew_answer`、`devcrew_approve`、`devcrew_reject`、`devcrew_continue`、`devcrew_artifact`。
@@ -34,7 +34,7 @@ codex plugin marketplace add lishen802/devcrew
 插件会用下面的命令启动 DevCrew MCP 服务：
 
 ```bash
-npm exec --silent --yes --package=@shenlee/devcrew@0.1.1 -- node -e "<DevCrew CLI wrapper>" -- serve --stdio
+npm exec --silent --yes --package=@shenlee/devcrew@0.1.2 -- node -e "<DevCrew CLI wrapper>" -- serve --stdio
 ```
 
 插件会锁定到已发布的 npm 包版本，因此用户不需要克隆源码，也不需要在安装时编译 TypeScript；只需要本机有 Node.js，并且 Codex 第一次启动 MCP 服务时可以访问网络。
@@ -95,12 +95,26 @@ devcrew serve --stdio
 
 插件会设置 `DEVCREW_HOST` 用于宿主识别，因此 `devcrew_start` 可以省略 `host`，除非你需要显式覆盖。DevCrew 会把最新 run 记录为当前仓库的 active run，后续 MCP 调用可以省略 `runId`。
 
-默认情况下 DevCrew 使用安全的 `plan` 模式。如果你希望 implementer/tester 阶段真正修改仓库并运行配置好的验证命令，需要明确要求 apply 模式：
+默认情况下 DevCrew 使用安全的 `plan` 模式。如果你希望隔离执行阶段真正修改文件，并在隔离测试阶段运行配置好的验证命令，需要明确要求 apply 模式：
 
 ```text
 使用 DevCrew apply 模式帮我实现 billing API 的审计日志功能。
 ```
 
+apply 模式的固定顺序是：
+
+```text
+需求确认
+-> 架构确认
+-> 实现计划确认
+-> 隔离执行
+-> 隔离测试
+-> 测试报告确认
+-> 将补丁晋升到需求方仓库
+```
+
+apply 模式要求项目是 Git 仓库、使用真实的 Codex 或 Claude SDK 后端，并且在开始隔离执行和最终晋升补丁时，需求方工作树都必须保持干净。实现计划审批后，需要额外调用一次 `devcrew_continue` 完成隔离执行，再调用一次进入隔离测试。测试门禁批准前，需求方仓库不会出现实现改动；如果驳回测试并提交反馈答案，流程会回到同一个隔离工作树的 `execution` 阶段，不会修改需求方仓库。
+
 DevCrew 会自动从常见项目清单中发现验证命令。当前规则会优先读取 `package.json` scripts（`validate`，然后是 `test`，再到 `typecheck`/`lint`），再按项目清单回退到 `go test ./...`、`cargo test` 或 `python -m pytest`。
 
 你也可以在 `.devcrew/config.json` 中显式覆盖：
@@ -133,7 +147,7 @@ npm pack --dry-run
 
 公开 npm 发布由 `npm publish` GitHub Actions 工作流处理。发布 GitHub Release 或手动触发 workflow 时，它会先运行验证，再执行 `npm pack --dry-run` 检查包内容，最后在配置 `NPM_TOKEN` 后使用 npm provenance 发布公开包。
 
-当 Codex 插件引用的 npm 版本发布完成后，运行真实 marketplace smoke test：
+发布 `@shenlee/devcrew@0.1.2` 后，再运行真实 marketplace smoke test。由于插件锁定了 npm 版本，这是发布后的检查：
 
 ```bash
 npm run smoke:codex-plugin

package/dist/packages/adapters/src/index.js

@@ -70,7 +70,7 @@ export function renderRolePrompt(input) {
             lines.push("", `### ${name}`, content.trim());
         }
     }
-    const canApply = executionMode === "apply" && (input.role === "implementer" || input.role === "tester");
+    const canApply = roleCanApply({ ...input, executionMode });
     const permissionInstruction = canApply
         ? input.role === "tester"
             ? "You may run validation commands needed for the approved scope and report exact evidence."
@@ -84,6 +84,7 @@ function titleForPhase(phase) {
         requirements: "Requirements",
         architecture: "Architecture",
         implementation: "Implementation Plan",
+        execution: "Implementation Review",
         testing: "Test Report",
         acceptance: "Acceptance",
         complete: "Acceptance",
@@ -155,7 +156,7 @@ export function extractClaudeResult(message) {
     return text;
 }
 function roleCanApply(input) {
-    return input.executionMode === "apply" && (input.role === "implementer" || input.role === "tester");
+    return input.executionMode === "apply" && (input.phase === "execution" || input.phase === "testing");
 }
 function codexSandboxForRole(input) {
     return roleCanApply(input) ? "workspace-write" : "read-only";

package/dist/packages/core/src/paths.js

@@ -9,6 +9,9 @@ export function runsDir(cwd) {
 export function runDir(cwd, runId) {
     return join(runsDir(cwd), runId);
 }
+export function executionWorktreePath(cwd, runId) {
+    return join(devcrewDir(cwd), "worktrees", runId);
+}
 export function statePath(cwd, runId) {
     return join(runDir(cwd, runId), "state.json");
 }

package/dist/packages/core/src/store.js

@@ -13,9 +13,15 @@ export async function saveState(state) {
 export async function loadState(cwd, runId) {
     const raw = await readFile(statePath(cwd, runId), "utf8");
     const parsed = JSON.parse(raw);
+    const executionWorkspace = parsed.executionWorkspace;
     return {
         ...parsed,
         executionMode: parsed.executionMode ?? "plan",
+        executionWorkspace: executionWorkspace &&
+            typeof executionWorkspace.path === "string" &&
+            typeof executionWorkspace.baseCommit === "string"
+            ? executionWorkspace
+            : undefined,
         changedFiles: Array.isArray(parsed.changedFiles) ? parsed.changedFiles : [],
         implementationDiff: typeof parsed.implementationDiff === "string" ? parsed.implementationDiff : "",
         verification: Array.isArray(parsed.verification) ? parsed.verification : [],

package/dist/packages/core/src/types.js

@@ -6,6 +6,7 @@ export const PHASES = [
     "requirements",
     "architecture",
     "implementation",
+    "execution",
     "testing",
     "acceptance",
     "complete",

package/dist/packages/core/src/version.js

@@ -1,2 +1,2 @@
-export const DEVCREW_VERSION = "0.1.1";
+export const DEVCREW_VERSION = "0.1.2";
 export const DEVCREW_NPM_PACKAGE = "@shenlee/devcrew";

package/dist/packages/core/src/workflow.js

@@ -10,20 +10,24 @@ function now() {
 function newRunId() {
     return `dc-${Date.now().toString(36)}-${randomUUID().slice(0, 8)}`;
 }
-export function nextPhaseAfterGate(gate) {
-    const nextByGate = {
-        requirements: "architecture",
-        architecture: "implementation",
-        implementation: "testing",
-        testing: "acceptance",
-    };
-    return nextByGate[gate];
+export function nextPhaseAfterGate(state, gate) {
+    switch (gate) {
+        case "requirements":
+            return "architecture";
+        case "architecture":
+            return "implementation";
+        case "implementation":
+            return state.executionMode === "apply" ? "execution" : "testing";
+        case "testing":
+            return "acceptance";
+    }
 }
 export function artifactForPhase(phase) {
     const artifactByPhase = {
         requirements: "requirements",
         architecture: "architecture",
         implementation: "implementation-plan",
+        execution: "implementation-review",
         testing: "test-report",
         acceptance: "acceptance",
         complete: "acceptance",
@@ -36,10 +40,15 @@ export function gateForPhase(phase) {
     }
     return undefined;
 }
-function assertCurrentGate(state, gate) {
+function assertPendingCurrentGate(state, gate) {
     const expected = gateForPhase(state.phase);
-    if (expected && expected !== gate) {
-        throw new Error(`Cannot act on ${gate} while current gate is ${expected}`);
+    if (expected !== gate) {
+        throw new Error(expected
+            ? `Cannot act on ${gate} while current gate is ${expected}`
+            : `Cannot act on ${gate} while workflow phase is ${state.phase}`);
+    }
+    if (state.status !== "awaiting_approval" || state.gates[gate] !== "pending") {
+        throw new Error(`Gate ${gate} is not pending approval`);
     }
 }
 async function writeCurrentArtifact(state) {
@@ -56,6 +65,9 @@ export async function startWorkflow(input, options = {}) {
     const config = await ensureConfig(cwd);
     const backend = input.backend ? parseBackend(input.backend) : config.defaultBackend === "host-preferred" ? host : config.defaultBackend;
     const executionMode = input.executionMode ? parseExecutionMode(input.executionMode) : config.executionMode;
+    if (executionMode === "apply" && backend === "local") {
+        throw new Error("DevCrew apply mode requires a codex or claude backend; local is plan-only");
+    }
     const createdAt = now();
     const state = {
         version: 1,
@@ -106,6 +118,9 @@ export async function continueWorkflow(input) {
         state.status = "complete";
         return saveState(state);
     }
+    if (state.phase === "execution") {
+        throw new Error("DevCrew execution phase requires orchestrated continuation");
+    }
     const gate = gateForPhase(state.phase);
     if (!gate) {
         state.status = "complete";
@@ -116,17 +131,29 @@ export async function continueWorkflow(input) {
     await writeCurrentArtifact(state);
     return saveState(state);
 }
-export async function approveWorkflow(input) {
+export async function validateWorkflowApproval(input) {
     const state = await getWorkflowStatus(input);
     const gate = parseGate(input.gate);
-    assertCurrentGate(state, gate);
+    if (state.gates[gate] === "approved") {
+        return state;
+    }
+    assertPendingCurrentGate(state, gate);
+    parseOptionalNote(input.note);
+    return state;
+}
+export async function approveWorkflow(input) {
+    const state = await validateWorkflowApproval(input);
+    const gate = parseGate(input.gate);
+    if (state.gates[gate] === "approved") {
+        return state;
+    }
     state.gates[gate] = "approved";
     state.approvals.push({
         gate,
         note: parseOptionalNote(input.note),
         createdAt: now(),
     });
-    const nextPhase = nextPhaseAfterGate(gate);
+    const nextPhase = nextPhaseAfterGate(state, gate);
     state.phase = nextPhase;
     state.status = "ready";
     return saveState(state);
@@ -134,7 +161,10 @@ export async function approveWorkflow(input) {
 export async function rejectWorkflow(input) {
     const state = await getWorkflowStatus(input);
     const gate = parseGate(input.gate);
-    assertCurrentGate(state, gate);
+    if (state.gates[gate] === "rejected") {
+        return state;
+    }
+    assertPendingCurrentGate(state, gate);
     state.gates[gate] = "rejected";
     state.status = "awaiting_input";
     state.feedback.push({
@@ -146,15 +176,16 @@ export async function rejectWorkflow(input) {
 }
 export async function answerWorkflow(input, options = {}) {
     const state = await getWorkflowStatus(input);
+    const gate = gateForPhase(state.phase);
+    if (state.status !== "awaiting_input" || !gate || state.gates[gate] !== "rejected") {
+        throw new Error("Workflow must be awaiting_input at a rejected current gate before recording an answer");
+    }
     state.answers.push({
         answer: parseAnswer(input.answer),
         createdAt: now(),
     });
-    const gate = gateForPhase(state.phase);
-    if (gate) {
-        state.gates[gate] = "pending";
-        state.status = "awaiting_approval";
-    }
+    state.gates[gate] = "pending";
+    state.status = "awaiting_approval";
     if (!options.skipArtifactWrite) {
         await writeCurrentArtifact(state);
     }