@shenlee/devcrew 0.1.1 → 0.1.3

package/packages/orchestrator/src/worktree.ts

@@ -0,0 +1,269 @@
+import { spawn } from "node:child_process";
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import {
+  executionWorktreePath,
+  runDir,
+  type ExecutionWorkspace,
+  type RunState,
+} from "../../core/src/index.js";
+
+export interface CapturedExecutionChanges {
+  changedFiles: string[];
+  patch: string;
+}
+
+const REPOSITORY_PATHS = [
+  ".",
+  ":(exclude).devcrew",
+  ":(exclude).devcrew/**",
+  ":(exclude)docs/devcrew",
+  ":(exclude)docs/devcrew/**",
+];
+
+async function runGit(
+  args: string[],
+  cwd: string,
+  stdin?: string,
+  env?: NodeJS.ProcessEnv,
+): Promise<string> {
+  return new Promise((resolveResult, rejectResult) => {
+    const child = spawn("git", args, { cwd, env, stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    let settled = false;
+
+    const rejectOnce = (error: Error): void => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      rejectResult(error);
+    };
+
+    child.stdout.on("data", (chunk: Buffer) => {
+      stdout += chunk.toString("utf8");
+    });
+    child.stderr.on("data", (chunk: Buffer) => {
+      stderr += chunk.toString("utf8");
+    });
+    child.on("error", rejectOnce);
+    child.on("close", (code) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (code === 0) {
+        resolveResult(stdout);
+        return;
+      }
+      rejectResult(new Error(`git ${args[0]} failed: ${(stderr || stdout).trim()}`));
+    });
+    child.stdin.end(stdin);
+  });
+}
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function assertCleanRequester(cwd: string): Promise<void> {
+  const status = await runGit(
+    [
+      "status",
+      "--porcelain",
+      "-uall",
+      "--",
+      ...REPOSITORY_PATHS,
+    ],
+    cwd,
+  );
+  if (status.trim()) {
+    throw new Error("DevCrew apply promotion requires a clean working tree");
+  }
+}
+
+function nulPaths(output: string): string[] {
+  return output.split("\0").filter(Boolean);
+}
+
+function parseChangedFiles(output: string): string[] {
+  const fields = nulPaths(output);
+  const paths: string[] = [];
+  for (let index = 0; index < fields.length; ) {
+    const status = fields[index++];
+    const firstPath = fields[index++];
+    if (!status || !firstPath) {
+      throw new Error("DevCrew could not parse git diff name status output");
+    }
+    paths.push(firstPath);
+    if (status.startsWith("R") || status.startsWith("C")) {
+      const secondPath = fields[index++];
+      if (!secondPath) {
+        throw new Error("DevCrew could not parse renamed git diff path");
+      }
+      paths.push(secondPath);
+    }
+  }
+  return [...new Set(paths)];
+}
+
+async function markUntrackedIntentToAdd(cwd: string, env?: NodeJS.ProcessEnv): Promise<void> {
+  const untracked = nulPaths(
+    await runGit(
+      ["ls-files", "--others", "--exclude-standard", "-z", "--", ...REPOSITORY_PATHS],
+      cwd,
+      undefined,
+      env,
+    ),
+  );
+  if (untracked.length > 0) {
+    await runGit(["add", "-N", "--", ...untracked], cwd, undefined, env);
+  }
+}
+
+interface CapturePatchOptions {
+  allowEmpty?: boolean;
+  env?: NodeJS.ProcessEnv;
+}
+
+async function capturePatch(
+  workspace: ExecutionWorkspace,
+  options: CapturePatchOptions = {},
+): Promise<CapturedExecutionChanges> {
+  await markUntrackedIntentToAdd(workspace.path, options.env);
+  const changedFiles = parseChangedFiles(
+    await runGit(
+      ["diff", "--name-status", "-z", workspace.baseCommit, "--", ...REPOSITORY_PATHS],
+      workspace.path,
+      undefined,
+      options.env,
+    ),
+  );
+  const patch = await runGit(
+    ["diff", "--binary", "--no-ext-diff", workspace.baseCommit, "--", ...REPOSITORY_PATHS],
+    workspace.path,
+    undefined,
+    options.env,
+  );
+  if (!options.allowEmpty && !patch.trim()) {
+    throw new Error("DevCrew apply implementer produced no repository changes");
+  }
+  return { changedFiles, patch };
+}
+
+async function captureRequesterChanges(state: RunState, workspace: ExecutionWorkspace): Promise<CapturedExecutionChanges> {
+  const indexPath = join(runDir(state.cwd, state.runId), "promotion.index");
+  await mkdir(dirname(indexPath), { recursive: true });
+  await rm(indexPath, { force: true });
+  const env = { ...process.env, GIT_INDEX_FILE: indexPath };
+  try {
+    await runGit(["read-tree", workspace.baseCommit], state.cwd, undefined, env);
+    return await capturePatch(
+      { path: state.cwd, baseCommit: workspace.baseCommit },
+      { allowEmpty: true, env },
+    );
+  } finally {
+    await rm(indexPath, { force: true });
+  }
+}
+
+export async function ensureExecutionWorkspace(state: RunState): Promise<ExecutionWorkspace> {
+  if (state.executionWorkspace && (await pathExists(state.executionWorkspace.path))) {
+    return state.executionWorkspace;
+  }
+
+  await assertCleanRequester(state.cwd);
+  const baseCommit = (await runGit(["rev-parse", "HEAD"], state.cwd)).trim();
+  const path = executionWorktreePath(state.cwd, state.runId);
+  await mkdir(dirname(path), { recursive: true });
+  await runGit(["worktree", "add", "--detach", path, baseCommit], state.cwd);
+  return { path, baseCommit };
+}
+
+export async function captureExecutionChanges(
+  workspace: ExecutionWorkspace,
+): Promise<CapturedExecutionChanges> {
+  const head = (await runGit(["rev-parse", "HEAD"], workspace.path)).trim();
+  if (head !== workspace.baseCommit) {
+    await runGit(["reset", "--mixed", workspace.baseCommit], workspace.path);
+  }
+  return capturePatch(workspace);
+}
+
+export async function promoteExecutionChanges(state: RunState): Promise<void> {
+  const workspace = state.executionWorkspace;
+  if (!workspace || !state.implementationDiff.trim()) {
+    throw new Error("DevCrew apply promotion requires reviewed execution changes");
+  }
+
+  const requesterHead = (await runGit(["rev-parse", "HEAD"], state.cwd)).trim();
+  if (requesterHead !== workspace.baseCommit) {
+    throw new Error("DevCrew apply promotion refused because requester HEAD changed");
+  }
+
+  const patchPath = join(runDir(state.cwd, state.runId), "implementation.patch");
+  await mkdir(dirname(patchPath), { recursive: true });
+  await writeFile(patchPath, state.implementationDiff);
+
+  const current = await captureRequesterChanges(state, workspace);
+  if (current.patch === state.implementationDiff) {
+    return;
+  }
+  if (current.patch.trim()) {
+    throw new Error("DevCrew apply promotion requires a clean working tree");
+  }
+  await assertCleanRequester(state.cwd);
+
+  await runGit(["apply", "--check", "--binary", patchPath], state.cwd);
+  await runGit(["apply", "--binary", patchPath], state.cwd);
+
+  const promoted = await captureRequesterChanges(state, workspace);
+  if (promoted.patch !== state.implementationDiff) {
+    try {
+      await runGit(["apply", "--reverse", "--binary", patchPath], state.cwd);
+    } catch (error) {
+      const detail = error instanceof Error ? `: ${error.message}` : "";
+      throw new Error(`DevCrew promoted patch verification failed and rollback failed${detail}`);
+    }
+    throw new Error("DevCrew promoted patch differs from the reviewed implementation diff");
+  }
+}
+
+export async function rollbackPromotedExecutionChanges(state: RunState): Promise<void> {
+  const workspace = state.executionWorkspace;
+  if (!workspace || !state.implementationDiff.trim()) {
+    throw new Error("DevCrew apply rollback requires reviewed execution changes");
+  }
+  const patchPath = join(runDir(state.cwd, state.runId), "implementation.patch");
+  await runGit(["apply", "--reverse", "--check", "--binary", patchPath], state.cwd);
+  await runGit(["apply", "--reverse", "--binary", patchPath], state.cwd);
+  const remaining = await captureRequesterChanges(state, workspace);
+  if (remaining.patch.trim()) {
+    throw new Error("DevCrew apply rollback left requester repository changes");
+  }
+}
+
+export async function cleanupExecutionWorkspace(state: RunState): Promise<void> {
+  const workspace = state.executionWorkspace;
+  if (!workspace) {
+    return;
+  }
+  if (await pathExists(workspace.path)) {
+    await runGit(["worktree", "remove", "--force", workspace.path], state.cwd);
+  }
+  await runGit(["worktree", "prune"], state.cwd);
+}
+
+export async function executionCwd(state: RunState): Promise<string> {
+  if (state.executionMode !== "apply") {
+    return state.cwd;
+  }
+  return (await ensureExecutionWorkspace(state)).path;
+}

package/packages/plugins/src/index.ts

@@ -3,7 +3,7 @@ import { access, copyFile, mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { DEFAULT_CONFIG, DEVCREW_NPM_PACKAGE, DEVCREW_VERSION, ROLE_SECTIONS } from "../../core/src/index.js";
+import { DEFAULT_CONFIG, DEVCREW_NPM_PACKAGE, DEVCREW_VERSION } from "../../core/src/index.js";
 
 export interface GeneratedPlugin {
   name: "devcrew";
@@ -45,48 +45,8 @@ async function writeCodexAssets(pluginRoot: string): Promise<void> {
   await copyFile(await bundledAssetPath("composer-icon.png"), join(assetDir, "composer-icon.png"));
 }
 
-function roleExpectations(name: string): string {
-  const sections = ROLE_SECTIONS[name as keyof typeof ROLE_SECTIONS];
-  if (!sections || sections.length === 0) {
-    return "";
-  }
-  return sections.map((s) => `- ${s.heading} (${s.description})`).join("\n");
-}
-
-async function writeRoleAgents(root: string, format: "codex" | "claude"): Promise<void> {
-  const roles = [
-    ["pm", "Product manager. Clarifies requirements, scope boundaries, success criteria, and requester approvals."],
-    ["architect", "technical architecture specialist. Designs implementation, deployment, interfaces, and review criteria."],
-    ["implementer", "Implementation engineer. Writes code according to approved architecture and discovered standards."],
-    ["tester", "Testing and acceptance specialist. Verifies functionality, regressions, and acceptance evidence."],
-  ] as const;
-
-  if (format === "claude") {
-    const agentDir = join(root, "agents");
-    await mkdir(agentDir, { recursive: true });
-    for (const [name, description] of roles) {
-      await writeFile(
-        join(agentDir, `${name}.md`),
-        `---\nname: ${name}\ndescription: ${description}\ntools: Read, Grep, Glob, Bash\n---\n\nYou are the DevCrew ${name} role. ${description} Return concise Markdown and keep inherited host permissions.\n\nProduce these required sections:\n\n${roleExpectations(name)}\n`,
-        "utf8",
-      );
-    }
-    return;
-  }
-
-  const agentDir = join(root, "agents");
-  await mkdir(agentDir, { recursive: true });
-  for (const [name, description] of roles) {
-    await writeFile(
-      join(agentDir, `${name}.toml`),
-      `name = "${name}"\ndescription = "${description}"\ndeveloper_instructions = """\nYou are the DevCrew ${name} role. ${description}\nReturn concise Markdown and keep inherited host permissions.\n\nProduce these required sections:\n${roleExpectations(name)}\n"""\n`,
-      "utf8",
-    );
-  }
-}
-
 function entrySkill(): string {
-  return `---\nname: devcrew\ndescription: Run the DevCrew PM -> architecture -> implementation -> testing workflow. Use when the user asks for structured feature or product development, requirements clarification, architecture review, implementation planning, testing acceptance, or Chinese requests such as 完整研发流程, 需求澄清, 产品经理, 架构师, 开发测试流程.\n---\n\nUse the DevCrew MCP tools to manage the workflow:\n\n1. Start with \`devcrew_start\` using the current repository cwd, mode, request, and optional executionMode. Host is inferred from the plugin's \`DEVCREW_HOST\`; pass host only for an explicit override. Omit executionMode unless the requester explicitly asks DevCrew to apply changes; the default safe mode is \`plan\`.\n2. After start, DevCrew records the active run for this repository. For follow-up tools, omit runId unless you need to target a different run explicitly.\n3. Use \`executionMode: "apply"\` only when the requester explicitly wants DevCrew to write code or run validation commands. This still inherits host sandbox, approval, and tool permissions.\n4. Use \`devcrew_status\` to show the current phase and pending gate.\n5. Use \`devcrew_answer\` when the requester gives clarification.\n6. Use \`devcrew_approve\` or \`devcrew_reject\` for each gate.\n7. Use \`devcrew_continue\` after approvals. This executes the next phase role, writes the phase artifact, and opens the next gate. The implementation phase also writes \`implementation-review\` for diff and architecture compliance review.\n8. Use \`devcrew_artifact\` to read generated requirements, architecture, implementation-plan, implementation-review, test-report, or acceptance files.\n\nDo not bypass host sandbox, approval, or tool permissions.\n`;
+  return `---\nname: devcrew\ndescription: Run the DevCrew PM -> architecture -> implementation -> testing workflow. Use when the user asks for structured feature or product development, requirements clarification, architecture review, implementation planning, testing acceptance, or Chinese requests such as 完整研发流程, 需求澄清, 产品经理, 架构师, 开发测试流程.\n---\n\nUse the DevCrew MCP tools to manage the workflow:\n\n1. Start with \`devcrew_start\` using the current repository cwd, mode, request, and optional \`executionMode\`. Host is inferred from the plugin's \`DEVCREW_HOST\`; pass host only for an explicit override. Omit \`executionMode\` unless the requester explicitly asks DevCrew to apply changes; the default safe mode is \`plan\`.\n2. After start, DevCrew records the active run for this repository. For follow-up tools, omit \`runId\` unless you need to target a different run explicitly.\n3. For \`executionMode: "apply"\`, choose an explicit \`executionPolicy\`. The default \`interactive-host\` pauses at implementation and testing for the host's native agent to work in DevCrew's isolated worktree. \`headless-restricted\` and \`headless-unattended\` are DevCrew SDK policies; they do not inherit the current host approval session.\n4. Use \`devcrew_status\` to show the current phase, pending gate, and any execution instruction.\n5. Use \`devcrew_answer\` when the requester gives clarification.\n6. Use \`devcrew_approve\` or \`devcrew_reject\` for each gate.\n7. Use \`devcrew_continue\` after approvals. Apply runs enter an \`implementation-review\` gate after execution: review the architect's \`architecture-review\` artifact before testing. For \`interactive-host\`, if status becomes \`awaiting_execution\`, perform the native-host work in the indicated worktree then call \`devcrew_complete_execution\`. For testing, include command, exit code, output, startedAt, and completedAt evidence.\n8. Failed verification is not approvable. Revise through \`devcrew_answer\`, or use \`devcrew_waive_verification\` only when the requester explicitly accepts the recorded risk and provides a reason.\n9. Use \`devcrew_artifact\` to read generated requirements, architecture, implementation-plan, implementation-review, architecture-review, test-report, or acceptance files.\n\nNever describe a nested SDK session as inheriting the current host's approval decisions.\n`;
 }
 
 function npmPackageSpecifier(): string {
@@ -169,7 +129,6 @@ export async function generateCodexPlugin(root: string): Promise<GeneratedPlugin
       devcrew: mcpServerConfig("codex"),
     },
   });
-  await writeRoleAgents(pluginRoot, "codex");
   return { name: "devcrew", path: pluginRoot };
 }
 
@@ -215,7 +174,6 @@ export async function generateClaudePlugin(root: string): Promise<GeneratedPlugi
       devcrew: mcpServerConfig("claude"),
     },
   });
-  await writeRoleAgents(pluginRoot, "claude");
   return { name: "devcrew", path: pluginRoot };
 }
 

package/packages/service/src/stdio.ts

@@ -2,14 +2,25 @@ import { callDevCrewTool, listDevCrewTools } from "./tools.js";
 import { DEVCREW_VERSION } from "../../core/src/index.js";
 
 interface JsonRpcRequest {
+  jsonrpc: "2.0";
   id?: string | number | null;
-  method?: string;
+  method: string;
   params?: Record<string, unknown>;
 }
 
 type JsonWriter = (message: unknown) => void;
 type RequestHandler = (request: JsonRpcRequest) => Promise<void>;
 
+function isJsonRpcRequest(value: unknown): value is JsonRpcRequest {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    !Array.isArray(value) &&
+    (value as { jsonrpc?: unknown }).jsonrpc === "2.0" &&
+    typeof (value as { method?: unknown }).method === "string"
+  );
+}
+
 function writeJson(message: unknown): void {
   process.stdout.write(`${JSON.stringify(message)}\n`);
 }
@@ -61,7 +72,7 @@ async function handleRequest(request: JsonRpcRequest, write: JsonWriter): Promis
       return;
     }
 
-    throw new Error(`Unsupported JSON-RPC method: ${request.method ?? "unknown"}`);
+    throw new Error(`Unsupported JSON-RPC method: ${request.method}`);
   } catch (error) {
     write({
       jsonrpc: "2.0",
@@ -85,9 +96,9 @@ export function createStdioLineProcessor(
       return queue;
     }
 
-    let request: JsonRpcRequest;
+    let request: unknown;
     try {
-      request = JSON.parse(trimmed) as JsonRpcRequest;
+      request = JSON.parse(trimmed) as unknown;
     } catch {
       write({
         jsonrpc: "2.0",
@@ -97,8 +108,18 @@ export function createStdioLineProcessor(
       return queue;
     }
 
-    queue = queue.then(() => handler(request));
-    return queue;
+    if (!isJsonRpcRequest(request)) {
+      write({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32600, message: "Invalid Request" },
+      });
+      return queue;
+    }
+
+    const task = queue.then(() => handler(request));
+    queue = task.catch(() => undefined);
+    return task;
   };
 }
 

package/packages/service/src/tools.ts

@@ -1,5 +1,4 @@
 import {
-  approveWorkflow,
   getArtifact,
   getActiveRunId,
   getWorkflowStatus,
@@ -9,9 +8,12 @@ import {
 } from "../../core/src/index.js";
 import {
   answerOrchestratedWorkflow,
+  approveOrchestratedWorkflow,
+  completeOrchestratedExecution,
   continueOrchestratedWorkflow,
   rejectOrchestratedWorkflow,
   startOrchestratedWorkflow,
+  waiveOrchestratedVerification,
 } from "../../orchestrator/src/index.js";
 
 export interface DevCrewTool {
@@ -73,6 +75,11 @@ export function listDevCrewTools(): DevCrewTool[] {
             enum: ["plan", "apply"],
             description: "Execution mode. Defaults to plan; apply must be explicit.",
           },
+          executionPolicy: {
+            type: "string",
+            enum: ["interactive-host", "headless-restricted", "headless-unattended"],
+            description: "Apply execution policy. Defaults to interactive-host; headless policies are explicit DevCrew SDK policies.",
+          },
           request: { type: "string" },
           backend: { type: "string", enum: ["codex", "claude", "local"] },
         },
@@ -105,7 +112,7 @@ export function listDevCrewTools(): DevCrewTool[] {
         properties: {
           cwd: cwdProperty,
           runId: runIdProperty,
-          gate: { type: "string", enum: ["requirements", "architecture", "implementation", "testing"] },
+          gate: { type: "string", enum: ["requirements", "architecture", "implementation", "implementation-review", "testing"] },
           note: { type: "string" },
         },
       },
@@ -119,7 +126,7 @@ export function listDevCrewTools(): DevCrewTool[] {
         properties: {
           cwd: cwdProperty,
           runId: runIdProperty,
-          gate: { type: "string", enum: ["requirements", "architecture", "implementation", "testing"] },
+          gate: { type: "string", enum: ["requirements", "architecture", "implementation", "implementation-review", "testing"] },
           feedback: { type: "string" },
         },
       },
@@ -133,6 +140,32 @@ export function listDevCrewTools(): DevCrewTool[] {
         properties: { cwd: cwdProperty, runId: runIdProperty },
       },
     },
+    {
+      name: "devcrew_complete_execution",
+      description: "Record completion by the native host for an interactive-host execution or testing step.",
+      inputSchema: {
+        type: "object",
+        required: ["cwd", "summary"],
+        properties: {
+          cwd: cwdProperty,
+          runId: runIdProperty,
+          summary: { type: "string" },
+          verification: {
+            type: "array",
+            description: "Required only when completing testing: command, exitCode, output, startedAt, and completedAt for each validation command.",
+          },
+        },
+      },
+    },
+    {
+      name: "devcrew_waive_verification",
+      description: "Record a reasoned risk waiver after failed apply-mode verification, then reopen the testing gate for approval.",
+      inputSchema: {
+        type: "object",
+        required: ["cwd", "reason"],
+        properties: { cwd: cwdProperty, runId: runIdProperty, reason: { type: "string" } },
+      },
+    },
     {
       name: "devcrew_artifact",
       description: "Read a generated workflow artifact.",
@@ -144,7 +177,7 @@ export function listDevCrewTools(): DevCrewTool[] {
           runId: runIdProperty,
           name: {
             type: "string",
-            enum: ["requirements", "architecture", "implementation-plan", "implementation-review", "test-report", "acceptance"],
+            enum: ["requirements", "architecture", "implementation-plan", "implementation-review", "architecture-review", "test-report", "acceptance"],
           },
         },
       },
@@ -193,7 +226,7 @@ export async function callDevCrewTool(name: string, args: Record<string, unknown
       return success(`${summarizeState(state)}. Answer recorded.`, { state });
     }
     if (name === "devcrew_approve") {
-      const state = await approveWorkflow((await withActiveRun(args)) as never);
+      const state = await approveOrchestratedWorkflow((await withActiveRun(args)) as never);
       return success(`${summarizeState(state)}. Gate approved.`, { state });
     }
     if (name === "devcrew_reject") {
@@ -204,6 +237,14 @@ export async function callDevCrewTool(name: string, args: Record<string, unknown
       const state = await continueOrchestratedWorkflow((await withActiveRun(args)) as never);
       return success(`${summarizeState(state)}.`, { state });
     }
+    if (name === "devcrew_complete_execution") {
+      const state = await completeOrchestratedExecution((await withActiveRun(args)) as never);
+      return success(`${summarizeState(state)}. Native host completion recorded.`, { state });
+    }
+    if (name === "devcrew_waive_verification") {
+      const state = await waiveOrchestratedVerification((await withActiveRun(args)) as never);
+      return success(`${summarizeState(state)}. Verification waiver recorded.`, { state });
+    }
     if (name === "devcrew_artifact") {
       const artifact = await getArtifact((await withActiveRun(args)) as never);
       return success(artifact.content, { artifact });

package/plugins/devcrew-codex/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "devcrew",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "DevCrew gated multi-role workflow service for Codex.",
   "author": {
     "name": "DevCrew Contributors",

package/plugins/devcrew-codex/.mcp.json

@@ -6,7 +6,7 @@
         "exec",
         "--silent",
         "--yes",
-        "--package=@shenlee/devcrew@0.1.1",
+        "--package=@shenlee/devcrew@0.1.3",
         "--",
         "node",
         "-e",

package/plugins/devcrew-codex/skills/devcrew/SKILL.md

@@ -5,13 +5,14 @@ description: Run the DevCrew PM -> architecture -> implementation -> testing wor
 
 Use the DevCrew MCP tools to manage the workflow:
 
-1. Start with `devcrew_start` using the current repository cwd, mode, request, and optional executionMode. Host is inferred from the plugin's `DEVCREW_HOST`; pass host only for an explicit override. Omit executionMode unless the requester explicitly asks DevCrew to apply changes; the default safe mode is `plan`.
-2. After start, DevCrew records the active run for this repository. For follow-up tools, omit runId unless you need to target a different run explicitly.
-3. Use `executionMode: "apply"` only when the requester explicitly wants DevCrew to write code or run validation commands. This still inherits host sandbox, approval, and tool permissions.
-4. Use `devcrew_status` to show the current phase and pending gate.
+1. Start with `devcrew_start` using the current repository cwd, mode, request, and optional `executionMode`. Host is inferred from the plugin's `DEVCREW_HOST`; pass host only for an explicit override. Omit `executionMode` unless the requester explicitly asks DevCrew to apply changes; the default safe mode is `plan`.
+2. After start, DevCrew records the active run for this repository. For follow-up tools, omit `runId` unless you need to target a different run explicitly.
+3. For `executionMode: "apply"`, choose an explicit `executionPolicy`. The default `interactive-host` pauses at implementation and testing for the host's native agent to work in DevCrew's isolated worktree. `headless-restricted` and `headless-unattended` are DevCrew SDK policies; they do not inherit the current host approval session.
+4. Use `devcrew_status` to show the current phase, pending gate, and any execution instruction.
 5. Use `devcrew_answer` when the requester gives clarification.
 6. Use `devcrew_approve` or `devcrew_reject` for each gate.
-7. Use `devcrew_continue` after approvals. This executes the next phase role, writes the phase artifact, and opens the next gate. The implementation phase also writes `implementation-review` for diff and architecture compliance review.
-8. Use `devcrew_artifact` to read generated requirements, architecture, implementation-plan, implementation-review, test-report, or acceptance files.
+7. Use `devcrew_continue` after approvals. Apply runs enter an `implementation-review` gate after execution: review the architect's `architecture-review` artifact before testing. For `interactive-host`, if status becomes `awaiting_execution`, perform the native-host work in the indicated worktree then call `devcrew_complete_execution`. For testing, include command, exit code, output, startedAt, and completedAt evidence.
+8. Failed verification is not approvable. Revise through `devcrew_answer`, or use `devcrew_waive_verification` only when the requester explicitly accepts the recorded risk and provides a reason.
+9. Use `devcrew_artifact` to read generated requirements, architecture, implementation-plan, implementation-review, architecture-review, test-report, or acceptance files.
 
-Do not bypass host sandbox, approval, or tool permissions.
+Never describe a nested SDK session as inheriting the current host's approval decisions.

package/scripts/smoke-codex-plugin.mjs

@@ -298,7 +298,7 @@ async function main() {
       await client.request("initialize", {
         protocolVersion: "2025-03-26",
         capabilities: {},
-        clientInfo: { name: "devcrew-codex-plugin-smoke", version: "0.1.1" },
+        clientInfo: { name: "devcrew-codex-plugin-smoke", version: "0.1.3" },
       });
       client.notify("notifications/initialized", {});
       const tools = await client.request("tools/list", {});

package/plugins/devcrew-codex/agents/architect.toml

@@ -1,6 +0,0 @@
-name = "architect"
-description = "technical architecture specialist. Designs implementation, deployment, interfaces, and review criteria."
-developer_instructions = """
-You are the DevCrew architect role. technical architecture specialist. Designs implementation, deployment, interfaces, and review criteria.
-Return concise Markdown and keep inherited host permissions.
-"""

package/plugins/devcrew-codex/agents/implementer.toml

@@ -1,6 +0,0 @@
-name = "implementer"
-description = "Implementation engineer. Writes code according to approved architecture and discovered standards."
-developer_instructions = """
-You are the DevCrew implementer role. Implementation engineer. Writes code according to approved architecture and discovered standards.
-Return concise Markdown and keep inherited host permissions.
-"""

package/plugins/devcrew-codex/agents/pm.toml

@@ -1,6 +0,0 @@
-name = "pm"
-description = "Product manager. Clarifies requirements, scope boundaries, success criteria, and requester approvals."
-developer_instructions = """
-You are the DevCrew pm role. Product manager. Clarifies requirements, scope boundaries, success criteria, and requester approvals.
-Return concise Markdown and keep inherited host permissions.
-"""

package/plugins/devcrew-codex/agents/tester.toml

@@ -1,6 +0,0 @@
-name = "tester"
-description = "Testing and acceptance specialist. Verifies functionality, regressions, and acceptance evidence."
-developer_instructions = """
-You are the DevCrew tester role. Testing and acceptance specialist. Verifies functionality, regressions, and acceptance evidence.
-Return concise Markdown and keep inherited host permissions.
-"""