@shenlee/devcrew 0.1.0

package/packages/plugins/src/index.ts

@@ -0,0 +1,211 @@
+import { constants } from "node:fs";
+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";
+
+export interface GeneratedPlugin {
+  name: "devcrew";
+  path: string;
+}
+
+export interface GeneratedMarketplace {
+  name: "devcrew";
+  path: string;
+}
+
+async function writeJson(path: string, value: unknown): Promise<void> {
+  await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+
+async function bundledAssetPath(name: string): Promise<string> {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    join(moduleDir, "..", "assets", name),
+    join(moduleDir, "..", "..", "..", "..", "packages", "plugins", "assets", name),
+  ];
+
+  for (const candidate of candidates) {
+    try {
+      await access(candidate, constants.R_OK);
+      return candidate;
+    } catch {
+      // Try the next layout: source tree first, compiled package second.
+    }
+  }
+
+  throw new Error(`Missing bundled DevCrew plugin asset: ${name}`);
+}
+
+async function writeCodexAssets(pluginRoot: string): Promise<void> {
+  const assetDir = join(pluginRoot, "assets");
+  await mkdir(assetDir, { recursive: true });
+  await copyFile(await bundledAssetPath("logo.png"), join(assetDir, "logo.png"));
+  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`;
+}
+
+function npmPackageSpecifier(): string {
+  return `${DEVCREW_NPM_PACKAGE}@${DEVCREW_VERSION}`;
+}
+
+export async function generateCodexPlugin(root: string): Promise<GeneratedPlugin> {
+  const pluginRoot = join(root, "plugins", "devcrew-codex");
+  await mkdir(join(pluginRoot, ".codex-plugin"), { recursive: true });
+  await mkdir(join(pluginRoot, "skills", "devcrew"), { recursive: true });
+  await writeCodexAssets(pluginRoot);
+  await writeJson(join(pluginRoot, ".codex-plugin", "plugin.json"), {
+    name: "devcrew",
+    version: DEVCREW_VERSION,
+    description: "DevCrew gated multi-role workflow service for Codex.",
+    author: {
+      name: "DevCrew Contributors",
+      url: "https://github.com/lishen802/devcrew",
+    },
+    homepage: "https://github.com/lishen802/devcrew#readme",
+    repository: "https://github.com/lishen802/devcrew",
+    license: "Apache-2.0",
+    keywords: ["codex", "agents", "workflow", "mcp", "skills"],
+    skills: "./skills/",
+    mcpServers: "./.mcp.json",
+    interface: {
+      displayName: "DevCrew",
+      shortDescription: "Run gated PM, architecture, implementation, and testing workflows.",
+      longDescription:
+        "DevCrew helps Codex run feature and product development through explicit requirements, architecture, implementation planning, and testing gates.",
+      developerName: "DevCrew Contributors",
+      category: "Productivity",
+      capabilities: ["Interactive", "Write"],
+      websiteURL: "https://github.com/lishen802/devcrew",
+      defaultPrompt: [
+        "Use DevCrew to plan this feature.",
+        "Use DevCrew to build this product.",
+        "Use DevCrew to review this implementation plan.",
+      ],
+      brandColor: "#2563EB",
+      composerIcon: "./assets/composer-icon.png",
+      logo: "./assets/logo.png",
+    },
+  });
+  await writeFile(join(pluginRoot, "skills", "devcrew", "SKILL.md"), entrySkill(), "utf8");
+  await writeJson(join(pluginRoot, ".mcp.json"), {
+    mcpServers: {
+      devcrew: {
+        command: "npx",
+        args: ["-y", npmPackageSpecifier(), "serve", "--stdio"],
+        env: { DEVCREW_HOST: "codex" },
+      },
+    },
+  });
+  await writeRoleAgents(pluginRoot, "codex");
+  return { name: "devcrew", path: pluginRoot };
+}
+
+export async function generateCodexMarketplace(root: string): Promise<GeneratedMarketplace> {
+  const marketplacePath = join(root, ".agents", "plugins", "marketplace.json");
+  await mkdir(join(root, ".agents", "plugins"), { recursive: true });
+  await writeJson(marketplacePath, {
+    name: "devcrew",
+    interface: {
+      displayName: "DevCrew",
+    },
+    plugins: [
+      {
+        name: "devcrew",
+        source: {
+          source: "local",
+          path: "./plugins/devcrew-codex",
+        },
+        policy: {
+          installation: "AVAILABLE",
+          authentication: "ON_INSTALL",
+        },
+        category: "Productivity",
+      },
+    ],
+  });
+  return { name: "devcrew", path: marketplacePath };
+}
+
+export async function generateClaudePlugin(root: string): Promise<GeneratedPlugin> {
+  const pluginRoot = join(root, "plugins", "devcrew-claude");
+  await mkdir(join(pluginRoot, ".claude-plugin"), { recursive: true });
+  await mkdir(join(pluginRoot, "skills", "devcrew"), { recursive: true });
+  await writeJson(join(pluginRoot, ".claude-plugin", "plugin.json"), {
+    name: "devcrew",
+    description: "DevCrew gated multi-role workflow service for Claude Code.",
+    version: DEVCREW_VERSION,
+    author: { name: "DevCrew Contributors" },
+  });
+  await writeFile(join(pluginRoot, "skills", "devcrew", "SKILL.md"), entrySkill(), "utf8");
+  await writeJson(join(pluginRoot, ".mcp.json"), {
+    mcpServers: {
+      devcrew: {
+        command: "npx",
+        args: ["-y", npmPackageSpecifier(), "serve", "--stdio"],
+        env: { DEVCREW_HOST: "claude" },
+      },
+    },
+  });
+  await writeRoleAgents(pluginRoot, "claude");
+  return { name: "devcrew", path: pluginRoot };
+}
+
+export async function initProject(root: string): Promise<{ codex: GeneratedPlugin; claude: GeneratedPlugin }> {
+  await mkdir(join(root, ".devcrew"), { recursive: true });
+  await mkdir(join(root, "docs", "devcrew"), { recursive: true });
+  await writeJson(join(root, ".devcrew", "config.json"), DEFAULT_CONFIG);
+  await writeFile(
+    join(root, ".devcrew", "standards.md"),
+    "# DevCrew Standards\n\nAdd project-specific coding, testing, documentation, and deployment rules here.\n",
+    "utf8",
+  );
+  const codex = await generateCodexPlugin(root);
+  await generateCodexMarketplace(root);
+  const claude = await generateClaudePlugin(root);
+  return { codex, claude };
+}

package/packages/service/src/index.ts

@@ -0,0 +1,2 @@
+export * from "./stdio.js";
+export * from "./tools.js";

package/packages/service/src/stdio.ts

@@ -0,0 +1,121 @@
+import { callDevCrewTool, listDevCrewTools } from "./tools.js";
+import { DEVCREW_VERSION } from "../../core/src/index.js";
+
+interface JsonRpcRequest {
+  id?: string | number | null;
+  method?: string;
+  params?: Record<string, unknown>;
+}
+
+type JsonWriter = (message: unknown) => void;
+type RequestHandler = (request: JsonRpcRequest) => Promise<void>;
+
+function writeJson(message: unknown): void {
+  process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+
+async function handleRequest(request: JsonRpcRequest, write: JsonWriter): Promise<void> {
+  if (request.method === "notifications/initialized") {
+    return;
+  }
+
+  if (request.id === undefined || request.id === null) {
+    return;
+  }
+
+  try {
+    if (request.method === "initialize") {
+      write({
+        jsonrpc: "2.0",
+        id: request.id,
+        result: {
+          protocolVersion: "2025-03-26",
+          capabilities: { tools: {} },
+          serverInfo: { name: "devcrew", version: DEVCREW_VERSION },
+        },
+      });
+      return;
+    }
+
+    if (request.method === "tools/list") {
+      write({
+        jsonrpc: "2.0",
+        id: request.id,
+        result: { tools: listDevCrewTools() },
+      });
+      return;
+    }
+
+    if (request.method === "tools/call") {
+      const params = request.params ?? {};
+      const name = params.name;
+      if (typeof name !== "string") {
+        throw new Error("tools/call params.name must be a string");
+      }
+      const result = await callDevCrewTool(name, (params.arguments ?? {}) as Record<string, unknown>);
+      write({
+        jsonrpc: "2.0",
+        id: request.id,
+        result,
+      });
+      return;
+    }
+
+    throw new Error(`Unsupported JSON-RPC method: ${request.method ?? "unknown"}`);
+  } catch (error) {
+    write({
+      jsonrpc: "2.0",
+      id: request.id,
+      error: {
+        code: -32000,
+        message: error instanceof Error ? error.message : String(error),
+      },
+    });
+  }
+}
+
+export function createStdioLineProcessor(
+  write: JsonWriter = writeJson,
+  handler: RequestHandler = (request) => handleRequest(request, write),
+): (line: string) => Promise<void> {
+  let queue = Promise.resolve();
+  return async (line: string): Promise<void> => {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      return queue;
+    }
+
+    let request: JsonRpcRequest;
+    try {
+      request = JSON.parse(trimmed) as JsonRpcRequest;
+    } catch {
+      write({
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: -32700, message: "Parse error" },
+      });
+      return queue;
+    }
+
+    queue = queue.then(() => handler(request));
+    return queue;
+  };
+}
+
+export function runStdioServer(): void {
+  let buffer = "";
+  const processLine = createStdioLineProcessor();
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (chunk) => {
+    buffer += chunk;
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      void processLine(trimmed);
+    }
+  });
+}

package/packages/service/src/tools.ts

@@ -0,0 +1,215 @@
+import {
+  approveWorkflow,
+  getArtifact,
+  getActiveRunId,
+  getWorkflowStatus,
+  setActiveRun,
+  type Host,
+  type RunState,
+} from "../../core/src/index.js";
+import {
+  answerOrchestratedWorkflow,
+  continueOrchestratedWorkflow,
+  rejectOrchestratedWorkflow,
+  startOrchestratedWorkflow,
+} from "../../orchestrator/src/index.js";
+
+export interface DevCrewTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: "object";
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+export interface ToolResult {
+  content: Array<{ type: "text"; text: string }>;
+  structuredContent?: Record<string, unknown>;
+  isError?: boolean;
+}
+
+const cwdProperty = { type: "string", description: "Repository working directory." };
+const runIdProperty = { type: "string", description: "DevCrew run id." };
+const hostValues = ["codex", "claude"] as const;
+
+function inferHost(env: NodeJS.ProcessEnv = process.env): Host {
+  const host = env.DEVCREW_HOST;
+  return host === "claude" || host === "codex" ? host : "codex";
+}
+
+async function withActiveRun(args: Record<string, unknown>): Promise<Record<string, unknown>> {
+  if (typeof args.runId === "string" && args.runId.trim()) {
+    return args;
+  }
+  if (typeof args.cwd !== "string" || !args.cwd.trim()) {
+    return args;
+  }
+  return { ...args, runId: await getActiveRunId(args.cwd) };
+}
+
+function withInferredHost(args: Record<string, unknown>): Record<string, unknown> {
+  if (typeof args.host === "string" && hostValues.includes(args.host as Host)) {
+    return args;
+  }
+  return { ...args, host: inferHost() };
+}
+
+export function listDevCrewTools(): DevCrewTool[] {
+  return [
+    {
+      name: "devcrew_start",
+      description: "Create a new gated DevCrew workflow run.",
+      inputSchema: {
+        type: "object",
+        required: ["cwd", "mode", "request"],
+        properties: {
+          cwd: cwdProperty,
+          host: { type: "string", enum: ["codex", "claude"], description: "Optional host override. Defaults to DEVCREW_HOST or codex." },
+          mode: { type: "string", enum: ["feature", "greenfield"] },
+          executionMode: {
+            type: "string",
+            enum: ["plan", "apply"],
+            description: "Execution mode. Defaults to plan; apply must be explicit.",
+          },
+          request: { type: "string" },
+          backend: { type: "string", enum: ["codex", "claude", "local"] },
+        },
+      },
+    },
+    {
+      name: "devcrew_status",
+      description: "Read the status of a DevCrew workflow run.",
+      inputSchema: {
+        type: "object",
+        required: ["cwd"],
+        properties: { cwd: cwdProperty, runId: runIdProperty },
+      },
+    },
+    {
+      name: "devcrew_answer",
+      description: "Record requester clarification input for the current gate.",
+      inputSchema: {
+        type: "object",
+        required: ["cwd", "answer"],
+        properties: { cwd: cwdProperty, runId: runIdProperty, answer: { type: "string" } },
+      },
+    },
+    {
+      name: "devcrew_approve",
+      description: "Approve the current workflow gate and advance to the next phase.",
+      inputSchema: {
+        type: "object",
+        required: ["cwd", "gate"],
+        properties: {
+          cwd: cwdProperty,
+          runId: runIdProperty,
+          gate: { type: "string", enum: ["requirements", "architecture", "implementation", "testing"] },
+          note: { type: "string" },
+        },
+      },
+    },
+    {
+      name: "devcrew_reject",
+      description: "Reject the current workflow gate and record feedback.",
+      inputSchema: {
+        type: "object",
+        required: ["cwd", "gate", "feedback"],
+        properties: {
+          cwd: cwdProperty,
+          runId: runIdProperty,
+          gate: { type: "string", enum: ["requirements", "architecture", "implementation", "testing"] },
+          feedback: { type: "string" },
+        },
+      },
+    },
+    {
+      name: "devcrew_continue",
+      description: "Continue a run after the previous gate was approved.",
+      inputSchema: {
+        type: "object",
+        required: ["cwd"],
+        properties: { cwd: cwdProperty, runId: runIdProperty },
+      },
+    },
+    {
+      name: "devcrew_artifact",
+      description: "Read a generated workflow artifact.",
+      inputSchema: {
+        type: "object",
+        required: ["cwd", "name"],
+        properties: {
+          cwd: cwdProperty,
+          runId: runIdProperty,
+          name: {
+            type: "string",
+            enum: ["requirements", "architecture", "implementation-plan", "implementation-review", "test-report", "acceptance"],
+          },
+        },
+      },
+    },
+  ];
+}
+
+function summarizeState(state: RunState): string {
+  const pendingGate = Object.entries(state.gates).find(([, status]) => status === "pending")?.[0] ?? "none";
+  const role = state.roles.at(-1);
+  const roleFallback =
+    role?.usedFallback === true ? (role.backend === "local" ? "local" : "sdk") : role ? "none" : "none";
+  return `Run ${state.runId}: phase=${state.phase}, status=${state.status}, execution_mode=${state.executionMode}, pending_gate=${pendingGate}, role_fallback=${roleFallback}`;
+}
+
+function success(text: string, structuredContent?: Record<string, unknown>): ToolResult {
+  return {
+    isError: false,
+    content: [{ type: "text", text }],
+    structuredContent,
+  };
+}
+
+function failure(error: unknown): ToolResult {
+  const message = error instanceof Error ? error.message : String(error);
+  return {
+    isError: true,
+    content: [{ type: "text", text: message }],
+    structuredContent: { error: message },
+  };
+}
+
+export async function callDevCrewTool(name: string, args: Record<string, unknown>): Promise<ToolResult> {
+  try {
+    if (name === "devcrew_start") {
+      const state = await startOrchestratedWorkflow(withInferredHost(args) as never);
+      await setActiveRun(state.cwd, state.runId);
+      return success(`${summarizeState(state)}. Review ${state.artifacts.requirements}`, { state });
+    }
+    if (name === "devcrew_status") {
+      const state = await getWorkflowStatus((await withActiveRun(args)) as never);
+      return success(summarizeState(state), { state });
+    }
+    if (name === "devcrew_answer") {
+      const state = await answerOrchestratedWorkflow((await withActiveRun(args)) as never);
+      return success(`${summarizeState(state)}. Answer recorded.`, { state });
+    }
+    if (name === "devcrew_approve") {
+      const state = await approveWorkflow((await withActiveRun(args)) as never);
+      return success(`${summarizeState(state)}. Gate approved.`, { state });
+    }
+    if (name === "devcrew_reject") {
+      const state = await rejectOrchestratedWorkflow((await withActiveRun(args)) as never);
+      return success(`${summarizeState(state)}. Gate rejected.`, { state });
+    }
+    if (name === "devcrew_continue") {
+      const state = await continueOrchestratedWorkflow((await withActiveRun(args)) as never);
+      return success(`${summarizeState(state)}.`, { state });
+    }
+    if (name === "devcrew_artifact") {
+      const artifact = await getArtifact((await withActiveRun(args)) as never);
+      return success(artifact.content, { artifact });
+    }
+    throw new Error(`Unknown DevCrew tool: ${name}`);
+  } catch (error) {
+    return failure(error);
+  }
+}

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

@@ -0,0 +1,41 @@
+{
+  "name": "devcrew",
+  "version": "0.1.0",
+  "description": "DevCrew gated multi-role workflow service for Codex.",
+  "author": {
+    "name": "DevCrew Contributors",
+    "url": "https://github.com/lishen802/devcrew"
+  },
+  "homepage": "https://github.com/lishen802/devcrew#readme",
+  "repository": "https://github.com/lishen802/devcrew",
+  "license": "Apache-2.0",
+  "keywords": [
+    "codex",
+    "agents",
+    "workflow",
+    "mcp",
+    "skills"
+  ],
+  "skills": "./skills/",
+  "mcpServers": "./.mcp.json",
+  "interface": {
+    "displayName": "DevCrew",
+    "shortDescription": "Run gated PM, architecture, implementation, and testing workflows.",
+    "longDescription": "DevCrew helps Codex run feature and product development through explicit requirements, architecture, implementation planning, and testing gates.",
+    "developerName": "DevCrew Contributors",
+    "category": "Productivity",
+    "capabilities": [
+      "Interactive",
+      "Write"
+    ],
+    "websiteURL": "https://github.com/lishen802/devcrew",
+    "defaultPrompt": [
+      "Use DevCrew to plan this feature.",
+      "Use DevCrew to build this product.",
+      "Use DevCrew to review this implementation plan."
+    ],
+    "brandColor": "#2563EB",
+    "composerIcon": "./assets/composer-icon.png",
+    "logo": "./assets/logo.png"
+  }
+}

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

@@ -0,0 +1,16 @@
+{
+  "mcpServers": {
+    "devcrew": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@shenlee/devcrew@0.1.0",
+        "serve",
+        "--stdio"
+      ],
+      "env": {
+        "DEVCREW_HOST": "codex"
+      }
+    }
+  }
+}

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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,6 @@
+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

@@ -0,0 +1,6 @@
+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.
+"""

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

@@ -0,0 +1,17 @@
+---
+name: devcrew
+description: 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 完整研发流程, 需求澄清, 产品经理, 架构师, 开发测试流程.
+---
+
+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.
+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.
+
+Do not bypass host sandbox, approval, or tool permissions.