@shenlee/devcrew 0.1.2 → 0.1.3

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

@@ -3,7 +3,8 @@ import { ensureConfig } from "./config.js";
 import { readArtifact, writeArtifact } from "./artifacts.js";
 import { discoverStandards } from "./standards.js";
 import { loadState, saveState } from "./store.js";
-import { parseAnswer, parseArtifactName, parseBackend, parseCwd, parseExecutionMode, parseFeedback, parseGate, parseHost, parseOptionalNote, parseRequest, parseRunId, parseWorkflowMode, } from "./validation.js";
+import { parseAnswer, parseArtifactName, parseBackend, parseCwd, parseExecutionMode, parseExecutionPolicy, parseFeedback, parseGate, parseHost, parseOptionalNote, parseRequest, parseRunId, parseWaiverReason, parseWorkflowMode, } from "./validation.js";
+import { GATES } from "./types.js";
 function now() {
     return new Date().toISOString();
 }
@@ -18,6 +19,8 @@ export function nextPhaseAfterGate(state, gate) {
             return "implementation";
         case "implementation":
             return state.executionMode === "apply" ? "execution" : "testing";
+        case "implementation-review":
+            return "testing";
         case "testing":
             return "acceptance";
     }
@@ -28,20 +31,32 @@ export function artifactForPhase(phase) {
         architecture: "architecture",
         implementation: "implementation-plan",
         execution: "implementation-review",
+        review: "architecture-review",
         testing: "test-report",
         acceptance: "acceptance",
         complete: "acceptance",
     };
     return artifactByPhase[phase];
 }
-export function gateForPhase(phase) {
-    if (phase === "requirements" || phase === "architecture" || phase === "implementation" || phase === "testing") {
-        return phase;
-    }
-    return undefined;
+export function gateForPhase(phase, enabledGates) {
+    const gate = phase === "review"
+        ? "implementation-review"
+        : (phase === "requirements" ||
+            phase === "architecture" ||
+            phase === "implementation" ||
+            phase === "testing"
+            ? phase
+            : undefined);
+    return gate && (!enabledGates || enabledGates.includes(gate)) ? gate : undefined;
+}
+function configuredGates(gates) {
+    const configured = new Set(gates.filter((gate) => GATES.includes(gate)));
+    configured.add("implementation-review");
+    configured.add("testing");
+    return [...configured];
 }
 function assertPendingCurrentGate(state, gate) {
-    const expected = gateForPhase(state.phase);
+    const expected = gateForPhase(state.phase, state.enabledGates);
     if (expected !== gate) {
         throw new Error(expected
             ? `Cannot act on ${gate} while current gate is ${expected}`
@@ -65,6 +80,8 @@ 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;
+    const executionPolicy = input.executionPolicy ? parseExecutionPolicy(input.executionPolicy) : "interactive-host";
+    const enabledGates = configuredGates(config.workflow.gates);
     if (executionMode === "apply" && backend === "local") {
         throw new Error("DevCrew apply mode requires a codex or claude backend; local is plan-only");
     }
@@ -76,20 +93,25 @@ export async function startWorkflow(input, options = {}) {
         host,
         mode,
         executionMode,
+        executionPolicy,
+        enabledGates,
+        artifactDirectory: config.workflow.artifactDirectory,
         backend,
         request,
         phase: "requirements",
-        status: "awaiting_approval",
+        status: enabledGates.includes("requirements") ? "awaiting_approval" : "ready",
         createdAt,
         updatedAt: createdAt,
         gates: {
-            requirements: "pending",
+            requirements: enabledGates.includes("requirements") ? "pending" : "not_started",
             architecture: "not_started",
             implementation: "not_started",
+            "implementation-review": "not_started",
             testing: "not_started",
         },
         artifacts: {},
         roles: [],
+        pendingQuestions: [],
         answers: [],
         approvals: [],
         feedback: [],
@@ -97,6 +119,7 @@ export async function startWorkflow(input, options = {}) {
         changedFiles: [],
         implementationDiff: "",
         verification: [],
+        verificationStatus: "not_run",
         lintResults: [],
     };
     if (!options.skipArtifactWrite) {
@@ -109,7 +132,10 @@ export async function getWorkflowStatus(input) {
 }
 export async function continueWorkflow(input) {
     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") {
         return state;
     }
     if (state.phase === "acceptance") {
@@ -121,8 +147,14 @@ export async function continueWorkflow(input) {
     if (state.phase === "execution") {
         throw new Error("DevCrew execution phase requires orchestrated continuation");
     }
-    const gate = gateForPhase(state.phase);
+    const configuredGate = gateForPhase(state.phase);
+    const gate = gateForPhase(state.phase, state.enabledGates);
     if (!gate) {
+        if (configuredGate) {
+            state.phase = nextPhaseAfterGate(state, configuredGate);
+            state.status = "ready";
+            return saveState(state);
+        }
         state.status = "complete";
         return saveState(state);
     }
@@ -176,7 +208,16 @@ export async function rejectWorkflow(input) {
 }
 export async function answerWorkflow(input, options = {}) {
     const state = await getWorkflowStatus(input);
-    const gate = gateForPhase(state.phase);
+    const gate = gateForPhase(state.phase, state.enabledGates);
+    if (state.status === "awaiting_input" && state.pendingQuestions.length > 0 && state.phase === "requirements") {
+        state.answers.push({
+            answer: parseAnswer(input.answer),
+            createdAt: now(),
+        });
+        state.pendingQuestions = [];
+        state.status = "ready";
+        return saveState(state);
+    }
     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");
     }
@@ -191,6 +232,23 @@ export async function answerWorkflow(input, options = {}) {
     }
     return saveState(state);
 }
+export async function waiveVerificationWorkflow(input) {
+    const state = await getWorkflowStatus(input);
+    if (state.executionMode !== "apply" ||
+        state.phase !== "testing" ||
+        state.status !== "awaiting_input" ||
+        state.gates.testing !== "rejected" ||
+        state.verificationStatus !== "failed") {
+        throw new Error("A verification waiver is only available after failed apply-mode testing");
+    }
+    state.verificationWaiver = {
+        reason: parseWaiverReason(input.reason),
+        createdAt: now(),
+    };
+    state.gates.testing = "pending";
+    state.status = "awaiting_approval";
+    return saveState(state);
+}
 export async function getArtifact(input) {
     const state = await getWorkflowStatus(input);
     return readArtifact(state, parseArtifactName(input.name));

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

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { runRole } from "../../adapters/src/index.js";
-import { answerWorkflow, approveWorkflow, artifactForPhase, artifactPath, ARTIFACTS, discoverCoverageCommands, discoverLintCommands, discoverVerifyCommands, gateForPhase, getWorkflowStatus, readConfig, rejectWorkflow, renderArtifact, saveState, startWorkflow, validateWorkflowApproval, } from "../../core/src/index.js";
+import { answerWorkflow, approveWorkflow, artifactForPhase, artifactPath, ARTIFACTS, discoverCoverageCommands, discoverLintCommands, discoverVerifyCommands, gateForPhase, getWorkflowStatus, nextPhaseAfterGate, readConfig, rejectWorkflow, renderArtifact, saveState, startWorkflow, validateWorkflowApproval, waiveVerificationWorkflow, } from "../../core/src/index.js";
 import { captureExecutionChanges, cleanupExecutionWorkspace, ensureExecutionWorkspace, promoteExecutionChanges, rollbackPromotedExecutionChanges, } from "./worktree.js";
 // Hard cap so a hung apply/verify command cannot block the serialized MCP loop.
 const COMMAND_TIMEOUT_MS = 300_000;
@@ -12,6 +12,7 @@ function roleForPhase(phase) {
         architecture: "architect",
         implementation: "implementer",
         execution: "implementer",
+        review: "architect",
         testing: "tester",
     };
     return roles[phase];
@@ -35,7 +36,7 @@ function priorArtifactNamesForPhase(phase) {
     return ARTIFACTS.slice(0, currentIndex);
 }
 async function writeMarkdownArtifact(state, artifact, markdown) {
-    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;
@@ -162,9 +163,96 @@ function verificationBlock(results) {
         .map((result) => `### ${result.command}\n\nExit Code: ${result.exitCode}\n\nOutput:\n\n\`\`\`text\n${result.output || "(no output)"}\n\`\`\``)
         .join("\n\n");
 }
+function verificationStatusFor(results) {
+    if (results.length === 0) {
+        return "not_run";
+    }
+    return results.every((result) => result.exitCode === 0) ? "passed" : "failed";
+}
+function setTestingGateFromVerification(state) {
+    if (state.verificationStatus === "failed") {
+        state.gates.testing = "rejected";
+        state.status = "awaiting_input";
+        state.feedback.push({
+            gate: "testing",
+            message: "Automated verification failed. Inspect the test report, 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, phase, workspacePath) {
+    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, summary) {
+    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,
+    };
+}
+function parseCompletionSummary(value) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error("summary must be a non-empty string");
+    }
+    return value.trim();
+}
+function parseCompletionVerification(value) {
+    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 appendExecutionSections(artifact, markdown, state) {
-    if (artifact === "test-report" && !markdown.includes("## Acceptance Evidence")) {
-        return `${markdown.trim()}\n\n## Acceptance Evidence\n\n${verificationBlock(state.verification)}\n`;
+    if (artifact === "architecture-review" && state.architectureReview) {
+        let content = markdown.trim();
+        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") {
+        let content = markdown.trim();
+        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 markdown;
 }
@@ -179,8 +267,20 @@ async function runCurrentPhaseRole(state, runner = 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",
@@ -188,9 +288,10 @@ async function runCurrentPhaseRole(state, runner = 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),
@@ -201,14 +302,16 @@ async function runCurrentPhaseRole(state, runner = 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);
@@ -217,13 +320,23 @@ async function runCurrentPhaseRole(state, runner = runRole) {
         return saveState(state);
     }
     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,
         role,
@@ -231,6 +344,7 @@ async function runCurrentPhaseRole(state, runner = runRole) {
         request: state.request,
         mode: state.mode,
         executionMode: state.executionMode,
+        executionPolicy: state.executionPolicy,
         cwd: roleCwd,
         standards: state.standards.combined,
         artifactPath: path,
@@ -240,19 +354,60 @@ async function runCurrentPhaseRole(state, runner = 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") {
+        if (!result.reviewDecision) {
+            throw new Error("DevCrew architecture review must return a structured review decision");
+        }
+        state.architectureReview = {
+            decision: result.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);
     state.roles.push({ ...result, markdown });
     state.artifacts[artifact] = await writeMarkdownArtifact(state, artifact, markdown);
-    state.gates[gate] = "pending";
-    state.status = "awaiting_approval";
+    state.executionInstruction = undefined;
+    if (state.phase === "requirements" && result.questions && result.questions.length > 0) {
+        state.pendingQuestions = result.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);
 }
 export async function startOrchestratedWorkflow(input, runner = runRole) {
@@ -261,7 +416,10 @@ export async function startOrchestratedWorkflow(input, runner = runRole) {
 }
 export async function continueOrchestratedWorkflow(input, runner = runRole) {
     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") {
         return state;
     }
     return runCurrentPhaseRole(state, runner);
@@ -296,6 +454,9 @@ export async function approveOrchestratedWorkflow(input) {
         return cleanupAfterApproval(before);
     }
     if (promotingTesting) {
+        if (before.verificationStatus === "failed" && !before.verificationWaiver) {
+            throw new Error("Failed verification cannot be promoted without an explicit verification waiver");
+        }
         await promoteExecutionChanges(before);
         let approved;
         try {
@@ -315,6 +476,61 @@ export async function approveOrchestratedWorkflow(input) {
     }
     return approveWorkflow(input);
 }
+export async function waiveOrchestratedVerification(input) {
+    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) {
+    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);
+    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) {
     return rejectWorkflow(input);
 }
@@ -329,9 +545,8 @@ export async function answerOrchestratedWorkflow(input, runner = runRole) {
         state.gates.testing = "not_started";
         return saveState(state);
     }
-    const gate = gateForPhase(state.phase);
     const role = roleForPhase(state.phase);
-    if (!gate || !role) {
+    if (!role) {
         return state;
     }
     // Re-run the current phase role so the artifact reflects the new answer and

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

@@ -2,7 +2,7 @@ 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";
+import { DEFAULT_CONFIG, DEVCREW_NPM_PACKAGE, DEVCREW_VERSION } from "../../core/src/index.js";
 async function writeJson(path, value) {
     await writeFile(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
 }
@@ -29,36 +29,8 @@ async function writeCodexAssets(pluginRoot) {
     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) {
-    const sections = ROLE_SECTIONS[name];
-    if (!sections || sections.length === 0) {
-        return "";
-    }
-    return sections.map((s) => `- ${s.heading} (${s.description})`).join("\n");
-}
-async function writeRoleAgents(root, format) {
-    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."],
-    ];
-    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() {
-    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() {
     return `${DEVCREW_NPM_PACKAGE}@${DEVCREW_VERSION}`;
@@ -136,7 +108,6 @@ export async function generateCodexPlugin(root) {
             devcrew: mcpServerConfig("codex"),
         },
     });
-    await writeRoleAgents(pluginRoot, "codex");
     return { name: "devcrew", path: pluginRoot };
 }
 export async function generateCodexMarketplace(root) {
@@ -180,7 +151,6 @@ export async function generateClaudePlugin(root) {
             devcrew: mcpServerConfig("claude"),
         },
     });
-    await writeRoleAgents(pluginRoot, "claude");
     return { name: "devcrew", path: pluginRoot };
 }
 export async function initProject(root) {