@shenlee/devcrew 0.1.2 → 0.1.4

package/packages/orchestrator/src/index.ts

@@ -5,6 +5,7 @@ import { dirname } from "node:path";
 import { runRole } from "../../adapters/src/index.js";
 import type { RoleRunInput } from "../../adapters/src/index.js";
 import {
+  abortWorkflow,
   answerWorkflow,
   approveWorkflow,
   artifactForPhase,
@@ -15,15 +16,19 @@ import {
   discoverVerifyCommands,
   gateForPhase,
   getWorkflowStatus,
+  nextPhaseAfterGate,
   readConfig,
   rejectWorkflow,
   renderArtifact,
   saveState,
   startWorkflow,
   validateWorkflowApproval,
+  waiveVerificationWorkflow,
   type AnswerWorkflowInput,
+  type AbortWorkflowInput,
   type ApproveWorkflowInput,
   type ArtifactName,
+  type CompleteExecutionInput,
   type Phase,
   type RejectWorkflowInput,
   type RoleResult,
@@ -31,6 +36,8 @@ import {
   type RunState,
   type StartWorkflowInput,
   type VerificationResult,
+  type VerificationStatus,
+  type WaiveVerificationInput,
 } from "../../core/src/index.js";
 import {
   captureExecutionChanges,
@@ -44,13 +51,15 @@ import {
 const COMMAND_TIMEOUT_MS = 300_000;
 
 type RoleRunner = (input: RoleRunInput) => Promise<RoleResult>;
+type ExecutingRole = Exclude<RoleResult["role"], "conductor">;
 
-function roleForPhase(phase: Phase): RoleResult["role"] | undefined {
-  const roles: Partial<Record<Phase, RoleResult["role"]>> = {
+function roleForPhase(phase: Phase): ExecutingRole | undefined {
+  const roles: Partial<Record<Phase, ExecutingRole>> = {
     requirements: "pm",
     architecture: "architect",
     implementation: "implementer",
     execution: "implementer",
+    review: "architect",
     testing: "tester",
   };
   return roles[phase];
@@ -64,6 +73,7 @@ function conductorDecision(state: RunState, role: RoleResult["role"], gate: stri
     summary,
     markdown: `# Conductor Decision\n\n${summary}\n`,
     usedFallback: false,
+    format: "legacy",
   };
 }
 
@@ -77,7 +87,7 @@ function priorArtifactNamesForPhase(phase: Phase): ArtifactName[] {
 }
 
 async function writeMarkdownArtifact(state: RunState, artifact: ArtifactName, markdown: string): Promise<string> {
-  const path = artifactPath(state.cwd, state.runId, artifact);
+  const path = artifactPath(state.cwd, state.runId, artifact, state.artifactDirectory);
   await mkdir(dirname(path), { recursive: true });
   await writeFile(path, markdown, "utf8");
   return path;
@@ -225,11 +235,151 @@ function verificationBlock(results: VerificationResult[]): string {
     .join("\n\n");
 }
 
-function appendExecutionSections(artifact: ArtifactName, markdown: string, state: RunState): string {
-  if (artifact === "test-report" && !markdown.includes("## Acceptance Evidence")) {
-    return `${markdown.trim()}\n\n## Acceptance Evidence\n\n${verificationBlock(state.verification)}\n`;
+function verificationStatusFor(results: VerificationResult[]): VerificationStatus {
+  if (results.length === 0) {
+    return "not_run";
+  }
+  return results.every((result) => result.exitCode === 0) ? "passed" : "failed";
+}
+
+function setTestingGateFromVerification(state: RunState): void {
+  if (state.verificationStatus !== "passed") {
+    state.gates.testing = "rejected";
+    state.status = "awaiting_input";
+    state.feedback.push({
+      gate: "testing",
+      message:
+        state.verificationStatus === "failed"
+          ? "Automated verification failed. Inspect the test report, revise the implementation, or record an explicit verification waiver with its reason."
+          : "No verification evidence was recorded. Configure or run validation, revise the implementation, or record an explicit verification waiver with its reason.",
+      createdAt: now(),
+    });
+    return;
+  }
+  state.gates.testing = "pending";
+  state.status = "awaiting_approval";
+}
+
+function executionInstructions(state: RunState, phase: "execution" | "testing", workspacePath: string): string {
+  if (phase === "execution") {
+    return `Use the native ${state.host} host agent to implement the approved change in ${workspacePath}. Do not modify the requester checkout at ${state.cwd}. When complete, call devcrew_complete_execution with a concise summary.`;
+  }
+  return `Use the native ${state.host} host agent to validate the approved change in ${workspacePath}. Then call devcrew_complete_execution with a concise summary and each command's exit code and output.`;
+}
+
+function hostCompletionResult(state: RunState, summary: string): RoleResult {
+  const role = state.phase === "execution" ? "implementer" : "tester";
+  const artifact = artifactForPhase(state.phase);
+  return {
+    role,
+    backend: state.backend,
+    summary: `${role} completed through the native ${state.host} host: ${summary}`,
+    markdown: `${renderArtifact(artifact, state).trim()}\n\n## Native Host Summary\n\n${summary}\n`,
+    usedFallback: false,
+    format: "legacy",
+  };
+}
+
+function parseCompletionSummary(value: unknown): string {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error("summary must be a non-empty string");
+  }
+  return value.trim();
+}
+
+function parseCompletionVerification(value: unknown): VerificationResult[] {
+  if (value === undefined) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    throw new Error("verification must be an array");
+  }
+  return value.map((entry, index) => {
+    if (
+      !entry ||
+      typeof entry !== "object" ||
+      typeof entry.command !== "string" ||
+      entry.command.trim().length === 0 ||
+      !Number.isInteger(entry.exitCode) ||
+      typeof entry.output !== "string" ||
+      typeof entry.startedAt !== "string" ||
+      typeof entry.completedAt !== "string"
+    ) {
+      throw new Error(`verification[${index}] must include command, integer exitCode, output, startedAt, and completedAt`);
+    }
+    return {
+      command: entry.command.trim(),
+      exitCode: entry.exitCode,
+      output: entry.output,
+      startedAt: entry.startedAt,
+      completedAt: entry.completedAt,
+    };
+  });
+}
+
+function structuredRoleResultBlock(result: RoleResult): string {
+  if (result.format !== "structured" || !result.structured) {
+    return "";
+  }
+  const data = result.structured;
+  const sections = [
+    "## Structured Role Result",
+    "",
+    `Schema Version: ${data.schemaVersion}`,
+    `Summary: ${data.summary}`,
+  ];
+  if (data.questions?.length) {
+    sections.push("", "### Questions", "", ...data.questions.map((question) => `- ${question.id}: ${question.prompt}`));
+  }
+  if (data.decisions?.length) {
+    sections.push("", "### Decisions", "", ...data.decisions.map((decision) => `- ${decision}`));
+  }
+  if (data.changedFiles?.length) {
+    sections.push("", "### Changed Files", "", ...data.changedFiles.map((file) => `- ${file}`));
+  }
+  if (data.evidence.length) {
+    sections.push("", "### Command Evidence", "");
+    for (const evidence of data.evidence) {
+      sections.push(`- \`${evidence.command}\` — exit code ${evidence.exitCode}`);
+      if (evidence.output) {
+        sections.push("", "```text", evidence.output, "```");
+      }
+    }
   }
-  return markdown;
+  if (data.testCases?.length) {
+    sections.push("", "### Test Cases", "", "| ID | Scenario | Type | Expected |", "| --- | --- | --- | --- |");
+    sections.push(...data.testCases.map((testCase) => `| ${testCase.id} | ${testCase.scenario} | ${testCase.type} | ${testCase.expected} |`));
+  }
+  if (data.risks.length) {
+    sections.push("", "### Risks", "", ...data.risks.map((risk) => `- ${risk}`));
+  }
+  return `\n\n${sections.join("\n")}`;
+}
+
+function appendExecutionSections(artifact: ArtifactName, markdown: string, state: RunState, result?: RoleResult): string {
+  let content = markdown.trim();
+  if (result?.format === "structured" && !content.includes("## Structured Role Result")) {
+    content += structuredRoleResultBlock(result);
+  }
+  if (artifact === "architecture-review" && state.architectureReview) {
+    if (!content.includes("## Review Decision")) {
+      content += `\n\n## Review Decision\n\nDecision: ${state.architectureReview.decision}\n\nSummary: ${state.architectureReview.summary}`;
+    }
+    return `${content}\n`;
+  }
+  if (artifact === "test-report") {
+    if (!content.includes("## Acceptance Evidence")) {
+      content += `\n\n## Acceptance Evidence\n\n${verificationBlock(state.verification)}`;
+    }
+    if (!content.includes("## Verification Outcome")) {
+      content += `\n\n## Verification Outcome\n\nStatus: ${state.verificationStatus}`;
+    }
+    if (state.verificationWaiver && !content.includes("## Verification Waiver")) {
+      content += `\n\n## Verification Waiver\n\nReason: ${state.verificationWaiver.reason}\nRecorded At: ${state.verificationWaiver.createdAt}`;
+    }
+    return `${content}\n`;
+  }
+  return `${content}\n`;
 }
 
 async function writeImplementationReview(state: RunState): Promise<void> {
@@ -248,9 +398,22 @@ async function runCurrentPhaseRole(state: RunState, runner: RoleRunner = runRole
     const workspace = await ensureExecutionWorkspace(state);
     state.executionWorkspace = workspace;
     state.verification = [];
+    state.verificationStatus = "not_run";
+    delete state.verificationWaiver;
     delete state.artifacts["test-report"];
     await saveState(state);
 
+    if (state.executionPolicy === "interactive-host") {
+      state.executionInstruction = {
+        phase: "execution",
+        workspacePath: workspace.path,
+        instructions: executionInstructions(state, "execution", workspace.path),
+        createdAt: now(),
+      };
+      state.status = "awaiting_execution";
+      return saveState(state);
+    }
+
     const result = await runner({
       backend: state.backend,
       role: "implementer",
@@ -258,9 +421,10 @@ async function runCurrentPhaseRole(state: RunState, runner: RoleRunner = runRole
       request: state.request,
       mode: state.mode,
       executionMode: "apply",
+      executionPolicy: state.executionPolicy,
       cwd: workspace.path,
       standards: state.standards.combined,
-      artifactPath: artifactPath(state.cwd, state.runId, "implementation-review"),
+      artifactPath: artifactPath(state.cwd, state.runId, "implementation-review", state.artifactDirectory),
       answers: state.answers.map((entry) => entry.answer),
       feedback: state.feedback.map((entry) => `${entry.gate}: ${entry.message}`),
       priorArtifacts: await readPriorArtifacts(state),
@@ -271,15 +435,17 @@ async function runCurrentPhaseRole(state: RunState, runner: RoleRunner = runRole
     state.changedFiles = captured.changedFiles;
     state.implementationDiff = captured.patch;
     state.roles.push(result);
+    state.executionInstruction = undefined;
     await writeImplementationReview(state);
-    state.phase = "testing";
+    state.phase = "review";
     state.status = "ready";
     return saveState(state);
   }
 
-  const gate = gateForPhase(state.phase);
+  const configuredGate = gateForPhase(state.phase);
+  const gate = gateForPhase(state.phase, state.enabledGates);
   const role = roleForPhase(state.phase);
-  if (!gate || !role) {
+  if (!role) {
     const artifact = artifactForPhase(state.phase);
     const markdown = renderArtifact(artifact, state);
     state.artifacts[artifact] = await writeMarkdownArtifact(state, artifact, markdown);
@@ -289,13 +455,24 @@ async function runCurrentPhaseRole(state: RunState, runner: RoleRunner = runRole
   }
 
   const artifact = artifactForPhase(state.phase);
-  const path = artifactPath(state.cwd, state.runId, artifact);
+  const path = artifactPath(state.cwd, state.runId, artifact, state.artifactDirectory);
   const applyingTesting = state.executionMode === "apply" && state.phase === "testing";
   const roleCwd = applyingTesting ? state.executionWorkspace?.path : state.cwd;
   if (!roleCwd) {
     throw new Error("DevCrew apply testing requires an execution workspace");
   }
-  state.roles.push(conductorDecision(state, role, gate));
+  state.roles.push(conductorDecision(state, role, gate ?? `${state.phase} automatic transition`));
+
+  if (applyingTesting && state.executionPolicy === "interactive-host") {
+    state.executionInstruction = {
+      phase: "testing",
+      workspacePath: roleCwd,
+      instructions: executionInstructions(state, "testing", roleCwd),
+      createdAt: now(),
+    };
+    state.status = "awaiting_execution";
+    return saveState(state);
+  }
 
   const result = await runner({
     backend: state.backend,
@@ -304,6 +481,7 @@ async function runCurrentPhaseRole(state: RunState, runner: RoleRunner = runRole
     request: state.request,
     mode: state.mode,
     executionMode: state.executionMode,
+    executionPolicy: state.executionPolicy,
     cwd: roleCwd,
     standards: state.standards.combined,
     artifactPath: path,
@@ -314,20 +492,65 @@ async function runCurrentPhaseRole(state: RunState, runner: RoleRunner = runRole
 
   if (applyingTesting && state.executionWorkspace) {
     state.verification = await runConfiguredVerification(state, roleCwd);
+    state.verificationStatus = verificationStatusFor(state.verification);
     const captured = await captureExecutionChanges(state.executionWorkspace);
     state.changedFiles = captured.changedFiles;
     state.implementationDiff = captured.patch;
     await writeImplementationReview(state);
   }
 
+  if (state.phase === "review") {
+    const reviewDecision = result.format === "structured" ? result.structured?.reviewDecision : result.reviewDecision;
+    if (!reviewDecision) {
+      throw new Error("DevCrew architecture review must return a structured review decision");
+    }
+    state.architectureReview = {
+      decision: reviewDecision,
+      summary: result.summary,
+      reviewedAt: now(),
+    };
+  }
+
   // When the backend cannot run a real SDK we keep a single deterministic
   // artifact source by rendering the rich phase template from the core layer.
   const baseMarkdown = result.usedFallback ? `${fallbackNotice(result)}${renderArtifact(artifact, state)}` : result.markdown;
-  const markdown = appendExecutionSections(artifact, baseMarkdown, state);
+  const markdown = appendExecutionSections(artifact, baseMarkdown, state, result);
   state.roles.push({ ...result, markdown });
   state.artifacts[artifact] = await writeMarkdownArtifact(state, artifact, markdown);
-  state.gates[gate] = "pending";
-  state.status = "awaiting_approval";
+  state.executionInstruction = undefined;
+  const questions = result.format === "structured"
+    ? result.structured?.questions?.map((question) => question.prompt) ?? []
+    : result.questions ?? [];
+  if (state.phase === "requirements" && questions.length > 0) {
+    state.pendingQuestions = questions;
+    state.gates.requirements = "not_started";
+    state.status = "awaiting_input";
+    return saveState(state);
+  }
+  if (state.phase === "review" && state.architectureReview?.decision === "changes_required") {
+    state.gates["implementation-review"] = "rejected";
+    state.status = "awaiting_input";
+    state.feedback.push({
+      gate: "implementation-review",
+      message: state.architectureReview.summary,
+      createdAt: now(),
+    });
+    return saveState(state);
+  }
+  if (!gate && configuredGate) {
+    state.phase = nextPhaseAfterGate(state, configuredGate);
+    state.status = "ready";
+    return saveState(state);
+  }
+  if (applyingTesting) {
+    setTestingGateFromVerification(state);
+  } else {
+    if (!gate) {
+      throw new Error(`DevCrew has no configured gate for ${state.phase}`);
+    }
+    state.gates[gate] = "pending";
+    state.status = "awaiting_approval";
+  }
   return saveState(state);
 }
 
@@ -338,7 +561,13 @@ export async function startOrchestratedWorkflow(input: StartWorkflowInput, runne
 
 export async function continueOrchestratedWorkflow(input: RunRef, runner: RoleRunner = runRole): Promise<RunState> {
   const state = await getWorkflowStatus(input);
-  if (state.status === "awaiting_approval" || state.status === "awaiting_input" || state.status === "complete") {
+  if (
+    state.status === "awaiting_approval" ||
+    state.status === "awaiting_input" ||
+    state.status === "awaiting_execution" ||
+    state.status === "complete" ||
+    state.status === "aborted"
+  ) {
     return state;
   }
 
@@ -377,6 +606,9 @@ export async function approveOrchestratedWorkflow(input: ApproveWorkflowInput):
     return cleanupAfterApproval(before);
   }
   if (promotingTesting) {
+    if (before.verificationStatus !== "passed" && !before.verificationWaiver) {
+      throw new Error("Verification must pass before promotion or have an explicit verification waiver");
+    }
     await promoteExecutionChanges(before);
     let approved: RunState;
     try {
@@ -396,10 +628,98 @@ export async function approveOrchestratedWorkflow(input: ApproveWorkflowInput):
   return approveWorkflow(input);
 }
 
+export async function waiveOrchestratedVerification(input: WaiveVerificationInput): Promise<RunState> {
+  const state = await waiveVerificationWorkflow(input);
+  const reportPath = state.artifacts["test-report"];
+  if (reportPath) {
+    const report = await readFile(reportPath, "utf8");
+    await writeFile(reportPath, appendExecutionSections("test-report", report, state), "utf8");
+  }
+  return state;
+}
+
+export async function completeOrchestratedExecution(input: CompleteExecutionInput): Promise<RunState> {
+  const state = await getWorkflowStatus(input);
+  const instruction = state.executionInstruction;
+  if (
+    state.executionMode !== "apply" ||
+    state.executionPolicy !== "interactive-host" ||
+    state.status !== "awaiting_execution" ||
+    !instruction ||
+    instruction.phase !== state.phase ||
+    !state.executionWorkspace ||
+    instruction.workspacePath !== state.executionWorkspace.path
+  ) {
+    throw new Error("DevCrew is not awaiting an interactive-host execution completion");
+  }
+  const summary = parseCompletionSummary(input.summary);
+
+  if (state.phase === "execution") {
+    if (input.verification !== undefined) {
+      throw new Error("verification can only be submitted after interactive-host testing");
+    }
+    const captured = await captureExecutionChanges(state.executionWorkspace);
+    state.changedFiles = captured.changedFiles;
+    state.implementationDiff = captured.patch;
+    state.lintResults = [];
+    state.roles.push(hostCompletionResult(state, summary));
+    state.executionInstruction = undefined;
+    await writeImplementationReview(state);
+    state.phase = "review";
+    state.status = "ready";
+    return saveState(state);
+  }
+
+  if (state.phase !== "testing") {
+    throw new Error(`Cannot complete interactive-host work during ${state.phase}`);
+  }
+  state.verification = parseCompletionVerification(input.verification);
+  state.verificationStatus = verificationStatusFor(state.verification);
+  const captured = await captureExecutionChanges(state.executionWorkspace);
+  state.changedFiles = captured.changedFiles;
+  state.implementationDiff = captured.patch;
+  await writeImplementationReview(state);
+  const result = hostCompletionResult(state, summary);
+  const artifact = artifactForPhase(state.phase);
+  const markdown = appendExecutionSections(artifact, result.markdown, state, result);
+  state.roles.push({ ...result, markdown });
+  state.artifacts[artifact] = await writeMarkdownArtifact(state, artifact, markdown);
+  state.executionInstruction = undefined;
+  setTestingGateFromVerification(state);
+  return saveState(state);
+}
+
 export async function rejectOrchestratedWorkflow(input: RejectWorkflowInput): Promise<RunState> {
   return rejectWorkflow(input);
 }
 
+export async function abortOrchestratedWorkflow(input: AbortWorkflowInput): Promise<RunState> {
+  const state = await abortWorkflow(input);
+  if (!state.executionWorkspace) {
+    return state;
+  }
+  try {
+    await cleanupExecutionWorkspace(state);
+  } catch {
+    return state;
+  }
+  state.executionWorkspace = undefined;
+  return saveState(state);
+}
+
+export async function recoverOrchestratedWorkflow(input: RunRef): Promise<RunState> {
+  const state = await getWorkflowStatus(input);
+  if (state.status !== "aborted" && state.status !== "complete") {
+    throw new Error("Only terminal DevCrew runs can be recovered");
+  }
+  if (!state.executionWorkspace) {
+    return state;
+  }
+  await cleanupExecutionWorkspace(state);
+  state.executionWorkspace = undefined;
+  return saveState(state);
+}
+
 export async function answerOrchestratedWorkflow(input: AnswerWorkflowInput, runner: RoleRunner = runRole): Promise<RunState> {
   const before = await getWorkflowStatus(input);
   const state = await answerWorkflow(input, { skipArtifactWrite: true });
@@ -413,10 +733,20 @@ export async function answerOrchestratedWorkflow(input: AnswerWorkflowInput, run
     state.gates.testing = "not_started";
     return saveState(state);
   }
+  if (
+    before.executionMode === "apply" &&
+    before.phase === "review" &&
+    before.gates["implementation-review"] === "rejected" &&
+    before.architectureReview?.decision === "changes_required"
+  ) {
+    state.phase = "execution";
+    state.status = "ready";
+    state.gates["implementation-review"] = "not_started";
+    return saveState(state);
+  }
 
-  const gate = gateForPhase(state.phase);
   const role = roleForPhase(state.phase);
-  if (!gate || !role) {
+  if (!role) {
     return state;
   }
 

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 };
 }